v8::internal Namespace Reference

Data Structures
class	CustomArguments
struct	SmiTagging
struct	SmiTagging< 4 >
struct	SmiTagging< 8 >
class	Internals
class	FrameFunctionIterator
class	Accessors
class	AllocationSiteContext
class	AllocationSiteCreationContext
class	AllocationSiteUsageContext
class	AllocationTraceNode
class	AllocationTraceTree
class	AddressToTraceMap
class	AllocationTracker
class	Malloced
class	AllStatic
class	FreeStoreAllocationPolicy
class	StringTracker
class	DeferredHandles
class	HandleScopeImplementer
class	Testing
class	BASE_EMBEDDED
class	CustomArgumentsBase
class	PropertyCallbackArguments
class	FunctionCallbackArguments
class	CpuFeatures
struct	Register
struct	SwVfpRegister
struct	DwVfpRegister
struct	LowDwVfpRegister
struct	QwNeonRegister
struct	CRegister
struct	VmovIndex
class	Assembler
class	StoreBufferOverflowStub
class	StringHelper
class	SubStringStub
class	StringCompareStub
class	WriteInt32ToHeapNumberStub
class	RecordWriteStub
class	DirectCEntryStub
class	NameDictionaryLookupStub
struct	PlatformCallInterfaceDescriptor
class	StringCharLoadGenerator
class	MathExpGenerator
class	Instruction
class	Registers
class	VFPRegisters
class	EntryFrameConstants
class	ExitFrameConstants
class	JavaScriptFrameConstants
class	ArgumentsAdaptorFrameConstants
class	ConstructFrameConstants
class	InternalFrameConstants
class	LInstruction
class	LTemplateResultInstruction
class	LTemplateInstruction
class	LGap
class	V8_FINAL
class	LControlInstruction
class	LCodeGen
class	LDeferredCode
class	MacroAssembler
class	CodePatcher
class	FrameAndConstantPoolScope
class	ConstantPoolUnavailableScope
class	RegExpMacroAssemblerARM
class	SimulatorStack
struct	OperandInitializer
struct	OperandInitializer< Smi * >
struct	OperandInitializer< ExternalReference >
struct	CPURegister
struct	FPRegister
class	CPURegList
class	Operand
class	MemOperand
class	PatchingAssembler
class	StoreRegistersStateStub
class	RestoreRegistersStateStub
class	DecoderVisitor
class	DispatchingDecoderVisitor
class	Decoder
class	Disassembler
class	PrintDisassembler
class	InstructionSequence
struct	CounterDescriptor
class	Counter
class	Instrument
class	LLoadKeyed
class	LLoadKeyedExternal
class	LLoadKeyedFixed
class	LLoadKeyedFixedDouble
class	LUnaryMathOperation
class	LMathAbsTagged
class	LStoreKeyed
class	LSubS
class	BranchOnCondition
class	CompareAndBranch
class	TestAndBranch
class	BranchIfNonZeroNumber
class	BranchIfHeapNumber
class	BranchIfRoot
class	UseScratchRegisterScope
class	InlineSmiCheckInfo
class	RegExpMacroAssemblerARM64
class	AssemblerBase
class	PredictableCodeSizeScope
class	RelocIterator
struct	PositionState
class	CallWrapper
class	NullCallWrapper
class	MultiplierAndShift
class	PerThreadAssertData
class	PerThreadAssertScopeBase
class	PerThreadAssertScope
class	PerIsolateAssertBase
class	PerIsolateAssertScope
class	PerThreadAssertScopeDebugOnly
class	PerIsolateAssertScopeDebugOnly
class	AstNodeFactory
class	AstNode
class	Statement
class	Expression
class	BreakableStatement
class	Declaration
class	Module
class	IterationStatement
class	ForEachStatement
class	JumpStatement
class	TryStatement
class	MaterializedLiteral
class	RegExpTree
struct	AtomicOps_x86CPUFeatureStruct
class	Bignum
class	NoTrackDoubleFieldsForSerializerScope
class	Bootstrapper
class	NativesExternalStringResource
struct	BuiltinDesc
class	BuiltinFunctionTable
class	Builtins
struct	CachedPower
class	PowersOfTenCache
struct	IdentifierStart
struct	IdentifierPart
struct	WhiteSpace
struct	WhiteSpaceOrLineTerminator
class	SamplingCircularQueue
class	CodeStubGraphBuilderBase
class	CodeStubGraphBuilder
class	PlatformCodeStub
struct	CodeStubInterfaceDescriptor
struct	CallInterfaceDescriptor
class	HydrogenCodeStub
class	RuntimeCallHelper
class	StubRuntimeCallHelper
class	NopRuntimeCallHelper
class	ToNumberStub
class	FastNewClosureStub
class	FastCloneShallowArrayStub
class	FastCloneShallowObjectStub
class	CreateAllocationSiteStub
class	InstanceofStub
class	ArrayConstructorStub
class	InternalArrayConstructorStub
class	MathPowStub
class	ICStub
class	FunctionPrototypeStub
class	StoreICStub
class	HICStub
class	HandlerStub
class	LoadFieldStub
class	StringLengthStub
class	KeyedStringLengthStub
class	StoreGlobalStub
class	CallApiFunctionStub
class	CallApiGetterStub
class	KeyedLoadFieldStub
class	BinaryOpICStub
class	ArrayPushStub
class	ICCompareStub
class	CompareNilICStub
class	CEntryStub
class	JSEntryStub
class	JSConstructEntryStub
class	ArgumentsAccessStub
class	RegExpExecStub
class	CallFunctionStub
class	CallConstructStub
class	StringCharCodeAtGenerator
class	StringCharFromCodeGenerator
class	StringCharAtGenerator
class	KeyedLoadDictionaryElementStub
class	KeyedLoadDictionaryElementPlatformStub
class	DoubleToIStub
class	KeyedLoadFastElementStub
class	KeyedStoreFastElementStub
class	TransitionElementsKindStub
class	ArrayConstructorStubBase
class	ArrayNoArgumentConstructorStub
class	ArraySingleArgumentConstructorStub
class	ArrayNArgumentsConstructorStub
class	InternalArrayConstructorStubBase
class	InternalArrayNoArgumentConstructorStub
class	InternalArraySingleArgumentConstructorStub
class	InternalArrayNArgumentsConstructorStub
class	KeyedStoreElementStub
class	ToBooleanStub
class	ElementsTransitionAndStoreStub
class	StoreArrayLiteralElementStub
class	StubFailureTrampolineStub
class	ProfileEntryHookStub
class	CallDescriptors
class	CodeGenerator
class	ElementsTransitionGenerator
class	CompilationSubCache
class	CompilationCacheScript
class	CompilationCacheEval
class	CompilationCacheRegExp
class	CompilationCache
class	CompilerIntrinsics
class	HOptimizedGraphBuilderWithPositions
struct	OffsetRange
class	CompilationInfo
class	CompilationInfoWithZone
class	OptimizedCompileJob
class	Compiler
class	Context
class	StatsTable
class	StatsCounter
class	Histogram
class	HistogramTimer
class	CodeEventRecord
class	CodeCreateEventRecord
class	CodeMoveEventRecord
class	SharedFunctionInfoMoveEventRecord
class	ReportBuiltinEventRecord
class	TickSampleEventRecord
class	CodeEventsContainer
class	ProfilerEventsProcessor
class	CpuProfiler
class	BitVector
class	DateCache
class	DateParser
class	Deoptimizer
class	FrameDescription
class	DeoptimizerData
class	MaterializedObjectStore
class	DiyFp
class	Double
struct	Effect
class	EffectsMixin
class	Effects
class	NestedEffectsBase
class	EffectsBase
class	NestedEffects
struct	InitializeFastElementsKindSequence
class	ElementsKindTraits
class	ElementsAccessorBase
class	FastElementsAccessor
class	FastSmiOrObjectElementsAccessor
class	FastPackedSmiElementsAccessor
class	FastHoleySmiElementsAccessor
class	FastPackedObjectElementsAccessor
class	FastHoleyObjectElementsAccessor
class	FastDoubleElementsAccessor
class	FastPackedDoubleElementsAccessor
class	FastHoleyDoubleElementsAccessor
class	TypedElementsAccessor
class	DictionaryElementsAccessor
class	SloppyArgumentsElementsAccessor
class	ElementsAccessor
class	Execution
class	StackGuard
class	SimpleStringResource
class	ExternalizeStringExtension
class	FreeBufferExtension
class	GCExtension
class	StatisticsExtension
class	TriggerFailureExtension
class	Factory
class	FeedbackSlotInterface
class	DeferredFeedbackSlotProcessor
class	UInt128
struct	JSArguments
struct	MaybeBoolFlag
struct	JSCallerSavedCodeData
class	InnerPointerToCodeCache
class	StackHandlerConstants
class	StandardFrameConstants
class	EntryFrame
class	EntryConstructFrame
class	ExitFrame
class	StandardFrame
class	JavaScriptFrame
class	StubFrame
class	OptimizedFrame
class	ArgumentsAdaptorFrame
class	InternalFrame
class	StubFailureTrampolineFrame
class	ConstructFrame
class	StackFrameIterator
class	StackTraceFrameIterator
class	SafeStackFrameIterator
class	BreakableStatementChecker
class	FullCodeGenerator
class	AccessorTable
class	BackEdgeTable
class	FuncNameInferrer
struct	ObjectGroup
struct	ImplicitRefGroup
struct	ObjectGroupConnection
struct	ObjectGroupRetainerInfo
class	GlobalHandles
class	EternalHandles
class	List
class	Handle
class	HandleScope
class	DeferredHandleScope
struct	HandleScopeData
class	TemplateHashMapImpl
class	TemplateHashMap
class	HeapProfiler
class	FindEntryById
class	SnapshotFiller
class	GcSubrootsEnumerator
class	IndexedReferencesExtractor
class	JSArrayBufferDataEntryAllocator
class	RootsReferencesExtractor
class	GlobalObjectsEnumerator
class	GlobalHandlesExtractor
class	BasicHeapEntriesAllocator
class	NativeGroupRetainedObjectInfo
struct	MaxDecimalDigitsIn
struct	MaxDecimalDigitsIn< 4 >
struct	MaxDecimalDigitsIn< 8 >
class	OutputStreamWriter
class	HeapSnapshot
class	HeapObjectsMap
class	HeapEntriesAllocator
class	HeapEntriesMap
class	HeapObjectsSet
class	SnapshottingProgressReportingInterface
class	V8HeapExplorer
class	NativeObjectsExplorer
class	HeapSnapshotGenerator
class	HeapSnapshotJSONSerializer
class	ScavengeVisitor
class	ScavengeWeakObjectRetainer
struct	WeakListVisitor
struct	WeakListVisitor< JSFunction >
struct	WeakListVisitor< Code >
struct	WeakListVisitor< Context >
struct	WeakListVisitor< JSArrayBufferView >
struct	WeakListVisitor< JSArrayBuffer >
struct	WeakListVisitor< AllocationSite >
class	NewSpaceScavenger
class	ScavengingVisitor
class	HeapObjectsFilter
class	UnreachableObjectsFilter
class	StoreBufferRebuilder
class	PromotionQueue
class	ExternalStringTable
class	Heap
class	HeapStats
class	AlwaysAllocateScope
class	GCCallbacksScope
class	VerifyPointersVisitor
class	VerifySmisVisitor
class	SpaceIterator
class	KeyedLookupCache
class	DescriptorLookupCache
class	RegExpResultsCache
class	WeakObjectRetainer
class	IntrusiveMarking
class	HAliasAnalyzer
class	BoundsCheckKey
class	BoundsCheckBbData
class	HBoundsCheckEliminationState
class	BoundsCheckTable
class	HBoundsCheckEliminationPhase
class	HBoundsCheckHoistingPhase
class	HCanonicalizePhase
struct	HCheckTableEntry
class	HCheckTable
class	HCheckMapsEffects
class	HCheckEliminationPhase
class	HDeadCodeEliminationPhase
class	HDehoistIndexComputationsPhase
class	HEnvironmentLivenessAnalysisPhase
class	HEscapeAnalysisPhase
class	NoEffects
class	NoState
class	HFlowEngine
class	GvnBasicBlockState
class	HInferRepresentationPhase
class	HInferTypesPhase
class	HUseListNode
class	HSourcePosition
class	HValue
class	HPositionInfo
class	HInstruction
class	HTemplateInstruction
class	HControlInstruction
class	HTemplateControlInstruction
class	HUnaryControlInstruction
class	HUnaryOperation
class	HCall
class	HUnaryCall
class	HBinaryCall
struct	InductionVariableLimitUpdate
class	HDematerializedObject
class	HBinaryOperation
class	HBitwiseBinaryOperation
class	HArithmeticBinaryOperation
class	HCompareNumericAndBranch
class	HCompareObjectEqAndBranch
class	HStringCompareAndBranch
class	HIsConstructCallAndBranch
class	ArrayInstructionInterface
class	HMaterializedLiteral
class	HFieldApproximation
class	HLoadEliminationTable
class	HLoadEliminationEffects
class	HLoadEliminationPhase
class	HMarkDeoptimizeOnUndefinedPhase
class	HComputeChangeUndefinedToNaN
class	HMarkUnreachableBlocksPhase
class	HOsrBuilder
class	Pending
class	HRangeAnalysisPhase
class	HRedundantPhiEliminationPhase
class	HMergeRemovableSimulatesPhase
class	HRepresentationChangesPhase
class	HStackCheckEliminationPhase
class	HStoreEliminationPhase
class	HUint32AnalysisPhase
class	PostorderProcessor
class	AstContext
class	HGraphBuilder
class	HOptimizedGraphBuilder
class	HPhase
class	I18N
class	DateFormat
class	NumberFormat
class	Collator
class	BreakIterator
struct	IntelDoubleRegister
struct	XMMRegister
struct	X87Register
class	RegExpMacroAssemblerIA32
class	IC
class	IC_Utility
class	LoadIC
class	KeyedLoadIC
class	StoreIC
class	KeyedStoreIC
class	BinaryOpIC
class	CompareIC
class	CompareNilIC
class	ToBooleanIC
class	IncrementalMarkingMarkingVisitor
class	IncrementalMarkingRootMarkingVisitor
class	IncrementalMarking
class	Interface
class	BacktrackStack
class	IrregexpInterpreter
struct	StaticInitializer
class	VMState
class	ThreadId
class	Isolate
class	FrequencyCollator
class	RegExpCompiler
class	RecursionCheck
class	VisitMarker
class	AlternativeGeneration
class	AlternativeGenerationList
class	RegExpExpansionLimiter
class	CharacterRangeSplitter
class	AddDispatchRange
class	RegExpImpl
class	CharacterRange
class	OutSet
class	DispatchTable
struct	NodeInfo
class	QuickCheckDetails
class	RegExpNode
class	Interval
class	SeqRegExpNode
class	ActionNode
class	TextNode
class	AssertionNode
class	BackReferenceNode
class	EndNode
class	NegativeSubmatchSuccess
class	Guard
class	GuardedAlternative
class	ChoiceNode
class	NegativeLookaheadChoiceNode
class	LoopChoiceNode
class	BoyerMoorePositionInfo
class	BoyerMooreLookahead
class	Trace
class	NodeVisitor
class	DispatchTableConstructor
class	Analysis
struct	RegExpCompileData
class	RegExpEngine
struct	LeakyInstanceTrait
struct	StaticallyAllocatedInstanceTrait
struct	DynamicallyAllocatedInstanceTrait
struct	DefaultConstructTrait
struct	DefaultCreateTrait
struct	ThreadSafeInitOnceTrait
struct	SingleThreadInitOnceTrait
struct	LazyInstanceImpl
struct	LazyStaticInstance
struct	LazyInstance
struct	LazyDynamicInstance
class	DefaultPlatform
class	TaskQueue
class	WorkerThread
class	ElementCmp
class	TypeImpl
class	LifetimePosition
class	UseInterval
class	UsePosition
class	LiveRange
class	LAllocatorPhase
class	LOperand
class	LUnallocated
class	LChunk
class	LPhase
class	LiveEditFunctionTracker
class	Log
class	PerfBasicLogger
class	PerfJitLogger
class	LowLevelLogger
class	JitLogger
class	Profiler
class	Ticker
class	EnumerateOptimizedFunctionsVisitor
class	Logger
class	CodeEventListener
class	CodeEventLogger
class	FrameScope
class	AllowExternalCallThatCantCauseGC
class	NoCurrentFrameScope
class	Comment
class	AllocationUtils
class	MarkCompactMarkingVisitor
class	CodeMarkingVisitor
class	SharedFunctionInfoMarkingVisitor
class	RootMarkingVisitor
class	StringTableCleaner
class	MarkCompactWeakObjectRetainer
class	PointersUpdatingVisitor
class	EvacuationWeakObjectRetainer
class	Marking
class	MarkingDeque
class	SlotsBufferAllocator
class	SlotsBuffer
class	CodeFlusher
class	MarkCompactCollector
class	MessageLocation
class	MessageHandler
struct	FPURegister
struct	FPUControlRegister
class	FPURegisters
class	RegExpMacroAssemblerMIPS
class	NativesCollection
class	SequentialStringKey
class	OneByteStringKey
class	SubStringKey
class	TwoByteStringKey
class	Utf8StringKey
class	ConsStringCaptureOp
class	StaticVisitorBase
class	VisitorDispatchTable
class	BodyVisitorBase
class	FlexibleBodyVisitor
class	FixedBodyVisitor
class	StaticNewSpaceVisitor
class	StaticMarkingVisitor
struct	DescriptorArrayAppender
struct	FixedArrayAppender
class	JSObjectWalkVisitor
class	IntrusiveMapTransitionIterator
class	IntrusivePrototypeTransitionIterator
class	TraversableMap
class	CodeCacheHashTableKey
class	PolymorphicCodeCacheHashTableKey
class	RawStringComparator
class	RawStringComparator< uint16_t, uint16_t >
class	RawStringComparator< uint8_t, uint8_t >
class	StringComparator
class	IteratingStringHasher
class	StringKey
class	StringSharedKey
class	RegExpKey
class	InternalizedStringKey
class	TwoCharHashTableKey
class	StringsKey
struct	EnumIndexComparator
class	Object
class	Smi
class	Failure
class	HeapObject
class	FixedBodyDescriptor
class	FlexibleBodyDescriptor
class	HeapNumber
class	JSReceiver
class	JSObject
class	FixedArrayBase
class	FixedArray
class	FixedDoubleArray
class	ConstantPoolArray
class	DescriptorArray
class	BaseShape
class	HashTable
class	HashTableKey
class	StringTableShape
class	StringTable
class	MapCacheShape
class	MapCache
class	Dictionary
class	NameDictionaryShape
class	NameDictionary
class	NumberDictionaryShape
class	SeededNumberDictionaryShape
class	UnseededNumberDictionaryShape
class	SeededNumberDictionary
class	UnseededNumberDictionary
class	ObjectHashTableShape
class	ObjectHashSet
class	ObjectHashTable
class	WeakHashTableShape
class	WeakHashTable
class	JSFunctionResultCache
class	ScopeInfo
class	NormalizedMapCache
class	ByteArray
class	FreeSpace
class	ExternalArray
class	ExternalUint8ClampedArray
class	ExternalInt8Array
class	ExternalUint8Array
class	ExternalInt16Array
class	ExternalUint16Array
class	ExternalInt32Array
class	ExternalUint32Array
class	ExternalFloat32Array
class	ExternalFloat64Array
class	FixedTypedArrayBase
class	FixedTypedArray
class	DeoptimizationInputData
class	DeoptimizationOutputData
class	Code
class	DependentCode
class	Map
class	Struct
class	Box
class	Script
class	SharedFunctionInfo
class	JSGeneratorObject
class	JSModule
class	JSFunction
class	JSGlobalProxy
class	GlobalObject
class	JSGlobalObject
class	JSBuiltinsObject
class	JSValue
class	JSDate
class	JSMessageObject
class	JSRegExp
class	CompilationCacheShape
class	CompilationCacheTable
class	CodeCache
class	CodeCacheHashTableShape
class	CodeCacheHashTable
class	PolymorphicCodeCache
class	PolymorphicCodeCacheHashTable
class	TypeFeedbackInfo
class	AllocationSite
class	AllocationMemento
class	AliasedArgumentsEntry
class	StringHasher
class	Name
class	Symbol
class	String
class	SeqString
class	SeqOneByteString
class	SeqTwoByteString
class	ConsString
class	SlicedString
class	ExternalString
class	ExternalAsciiString
class	ExternalTwoByteString
class	FlatStringReader
class	ConsStringNullOp
class	ConsStringIteratorOp
class	StringCharacterStream
class	VectorIterator
class	Oddball
class	Cell
class	PropertyCell
class	JSProxy
class	JSFunctionProxy
class	JSSet
class	JSMap
class	JSWeakCollection
class	JSWeakMap
class	JSWeakSet
class	JSArrayBuffer
class	JSArrayBufferView
class	JSTypedArray
class	JSDataView
class	Foreign
class	JSArray
class	JSRegExpResult
class	AccessorInfo
struct	BitmaskCompareDescriptor
struct	PointerCompareDescriptor
struct	PrimitiveValueDescriptor
struct	ObjectDerefenceDescriptor
struct	PointerShiftDescriptor
struct	DeclaredAccessorDescriptorData
class	DeclaredAccessorDescriptorIterator
class	DeclaredAccessorDescriptor
class	DeclaredAccessorInfo
class	ExecutableAccessorInfo
class	AccessorPair
class	AccessCheckInfo
class	InterceptorInfo
class	CallHandlerInfo
class	TemplateInfo
class	FunctionTemplateInfo
class	ObjectTemplateInfo
class	SignatureInfo
class	TypeSwitchInfo
class	VisitorSynchronization
class	StructBodyDescriptor
class	BooleanBit
struct	OneArgFunction
class	OptimizingCompilerThread
class	ZoneListWrapper
class	ScriptDataImpl
class	PreParserApi
class	BufferedZoneList
class	RegExpBuilder
class	ParserTraits
class	Parser
class	CompileTimeValue
struct	CreateSemaphoreTrait
struct	LazySemaphore
class	PosixMemoryMappedFile
class	TimezoneCache
class	Thread
struct	StackWalker
class	Win32Time
class	Win32MemoryMappedFile
class	OS
class	VirtualMemory
struct	PreparseDataConstants
class	ParserRecorder
class	SingletonLogger
class	CompleteParserRecorder
class	ParserBase
class	PreParserIdentifier
class	PreParserExpression
class	PreParserExpressionList
class	PreParserScope
class	PreParserFactory
class	PreParserTraits
class	PreParser
class	DeleteNodesCallback
struct	NodesPair
class	Position
class	StringsStorage
class	CodeEntry
class	ProfileNode
class	ProfileTree
class	CpuProfile
class	CodeMap
class	CpuProfilesCollection
class	ProfileGenerator
class	Representation
class	FieldDescriptor
class	ConstantDescriptor
class	CallbacksDescriptor
class	PropertyIndex
class	PrintablePrinter
class	RegExpMacroAssemblerTracer
struct	DisjunctDecisionRow
class	RegExpMacroAssembler
class	NativeRegExpMacroAssembler
class	RegExpStackScope
class	RegExpStack
class	Processor
class	Rewriter
class	RuntimeProfiler
class	FixedArrayBuilder
class	ReplacementStringBuilder
class	CompiledReplacement
class	ActivationsFinder
class	ArrayConcatVisitor
class	RuntimeState
class	Runtime
class	AllocateDoubleAlignFlag
class	AllocateTargetSpace
class	DeclareGlobalsEvalFlag
class	DeclareGlobalsNativeFlag
class	DeclareGlobalsStrictMode
class	SamplerThread
struct	RegisterState
struct	TickSample
class	Sampler
class	BufferedUtf16CharacterStream
class	GenericStringUtf16CharacterStream
class	Utf8ToUtf16CharacterStream
class	ExternalTwoByteStringUtf16CharacterStream
class	Utf16CharacterStream
class	UnicodeCache
class	DuplicateFinder
class	LiteralBuffer
class	Scanner
class	ContextSlotCache
class	ModuleInfo
class	VarAndOrder
class	VariableMap
class	DynamicScopePart
class	Scope
class	CodeAddressMap
class	ExternalReferenceTable
class	ExternalReferenceEncoder
class	ExternalReferenceDecoder
class	SnapshotByteSource
class	SerializerDeserializer
class	Deserializer
class	SnapshotByteSink
class	SerializationAddressMapper
class	Serializer
class	PartialSerializer
class	StartupSerializer
class	SmallPointerList
class	SmartPointerBase
struct	ArrayDeallocator
class	SmartArrayPointer
struct	ObjectDeallocator
class	SmartPointer
class	Snapshot
class	MarkBit
class	Bitmap
class	MemoryChunk
class	Page
class	LargePage
class	Space
class	CodeRange
class	SkipList
class	MemoryAllocator
class	ObjectIterator
class	HeapObjectIterator
class	AllocationInfo
class	FreeListNode
class	FreeListCategory
class	FreeList
class	PagedSpace
class	HistogramInfo
class	NewSpacePage
class	SemiSpace
class	SemiSpaceIterator
class	NewSpace
class	OldSpace
class	MapSpace
class	CellSpace
class	PropertyCellSpace
class	LargeObjectSpace
class	LargeObjectIterator
class	SplayTree
class	StoreBuffer
class	StoreBufferRebuildScope
class	DontMoveStoreBufferEntriesScope
class	StringSearchBase
class	StringSearch
class	StringAllocator
class	HeapStringAllocator
class	NoAllocationStringAllocator
class	FmtElm
class	StringStream
class	SimpleListPrinter
class	SCTableReference
class	StubCache
class	BaseLoadStoreStubCompiler
class	LoadStubCompiler
class	KeyedLoadStubCompiler
class	StoreStubCompiler
class	KeyedStoreStubCompiler
class	SweeperThread
class	Token
class	TransitionArray
class	TrigonometricLookupTable
class	TypeFeedbackOracle
struct	TypeImplIteratorAux
struct	TypeImplIteratorAux< Config, i::Map >
struct	TypeImplIteratorAux< Config, i::Object >
struct	ZoneTypeConfig
struct	HeapTypeConfig
struct	BoundsImpl
class	AstTyper
class	UniqueSet
class	URIUnescape
class	URIEscape
class	BitFieldBase
class	BitField
class	BitField64
class	StaticResource
class	Access
class	Vector
class	SetOncePointer
class	EmbeddedVector
class	ScopedVector
class	Collector
class	SequenceCollector
struct	BitCastHelper
struct	BitCastHelper< Dest, Source * >
class	EmbeddedContainer
class	EmbeddedContainer< ElementType, 0 >
class	SimpleStringBuilder
class	EnumSet
class	TypeFeedbackId
class	BailoutId
class	ContainerPointerWrapper
class	Counters
class	V8
struct	CodeDesc
union	DoubleRepresentation
union	IeeeDoubleLittleEndianArchType
union	IeeeDoubleBigEndianArchType
struct	AccessorDescriptor
class	Memory
class	ThreadState
class	ThreadVisitor
class	ThreadManager
class	AsciiStringAdapter
class	StringBuilder
class	Variable
class	Version
class	SmiOperationExecutionMode
struct	SmiIndex
class	RegExpMacroAssemblerX64
class	zone_allocator
class	Segment
class	Zone
class	ZoneObject
struct	ZoneScope
struct	ZoneAllocationPolicy
class	ZoneList
class	ZoneSplayTree
struct	PrecomputedFixed
struct	PrecomputedPrecision
struct	PrecomputedShortest
class	PrintExtension
class	ProfilerExtension
struct	CompleteParserRecorderFriend
class	TestMemoryAllocatorScope
class	TestCodeRangeScope
class	TraceExtension

Typedefs
typedef SmiTagging < kApiPointerSize >	PlatformSmiTagging
typedef DwVfpRegister	DoubleRegister
typedef QwNeonRegister	QuadRegister
typedef int32_t	Instr
typedef uint32_t	SRegisterFieldMask
typedef Object *	JSCallerSavedBuffer [kNumJSCallerSaved]
typedef int(*	arm_regexp_matcher )(String *, int, const byte *, const byte *, void *, int *, int, Address, int, Isolate *)
typedef int(*	arm64_regexp_matcher )(String *input, int64_t start_offset, const byte *input_start, const byte *input_end, int *output, int64_t output_size, Address stack_base, int64_t direct_call, void *return_address, Isolate *isolate)
typedef PerThreadAssertScopeDebugOnly < HANDLE_ALLOCATION_ASSERT, false >	DisallowHandleAllocation
typedef PerThreadAssertScopeDebugOnly < HANDLE_ALLOCATION_ASSERT, true >	AllowHandleAllocation
typedef PerThreadAssertScopeDebugOnly < HEAP_ALLOCATION_ASSERT, false >	DisallowHeapAllocation
typedef PerThreadAssertScopeDebugOnly < HEAP_ALLOCATION_ASSERT, true >	AllowHeapAllocation
typedef PerThreadAssertScopeDebugOnly < HANDLE_DEREFERENCE_ASSERT, false >	DisallowHandleDereference
typedef PerThreadAssertScopeDebugOnly < HANDLE_DEREFERENCE_ASSERT, true >	AllowHandleDereference
typedef PerThreadAssertScopeDebugOnly < DEFERRED_HANDLE_DEREFERENCE_ASSERT, false >	DisallowDeferredHandleDereference
typedef PerThreadAssertScopeDebugOnly < DEFERRED_HANDLE_DEREFERENCE_ASSERT, true >	AllowDeferredHandleDereference
typedef PerThreadAssertScopeDebugOnly < CODE_DEPENDENCY_CHANGE_ASSERT, false >	DisallowCodeDependencyChange
typedef PerThreadAssertScopeDebugOnly < CODE_DEPENDENCY_CHANGE_ASSERT, true >	AllowCodeDependencyChange
typedef PerIsolateAssertScope < JAVASCRIPT_EXECUTION_ASSERT, false >	DisallowJavascriptExecution
typedef PerIsolateAssertScope < JAVASCRIPT_EXECUTION_ASSERT, true >	AllowJavascriptExecution
typedef PerIsolateAssertScope < JAVASCRIPT_EXECUTION_THROWS, false >	ThrowOnJavascriptExecution
typedef PerIsolateAssertScope < JAVASCRIPT_EXECUTION_THROWS, true >	NoThrowOnJavascriptExecution
typedef PerIsolateAssertScopeDebugOnly < ALLOCATION_FAILURE_ASSERT, false >	DisallowAllocationFailure
typedef PerIsolateAssertScopeDebugOnly < ALLOCATION_FAILURE_ASSERT, true >	AllowAllocationFailure
typedef ZoneList< Handle < String > >	ZoneStringList
typedef ZoneList< Handle < Object > >	ZoneObjectList
typedef int32_t	Atomic32
typedef intptr_t	AtomicWord
typedef char	__tsan_atomic8
typedef short	__tsan_atomic16
typedef int	__tsan_atomic32
typedef long	__tsan_atomic64
typedef char	__tsan_atomic128
typedef double(*	UnaryMathFunction )(double x)
typedef SimpleStringResource < char, v8::String::ExternalAsciiStringResource >	SimpleAsciiStringResource
typedef SimpleStringResource < uc16, v8::String::ExternalStringResource >	SimpleTwoByteStringResource
typedef uint32_t	RegList
typedef uint8_t	byte
typedef byte *	Address
typedef uint16_t	uc16
typedef int32_t	uc32
typedef TemplateHashMapImpl < FreeStoreAllocationPolicy >	HashMap
typedef void *	HeapThing
typedef String *(*	ExternalStringTableUpdaterCallback )(Heap *heap, Object **pointer)
typedef void(*	ScavengingCallback )(Map *map, HeapObject **slot, HeapObject *object)
typedef UniqueSet< Map > *	MapSet
typedef EnumSet< GVNFlag, int32_t >	GVNFlagSet
typedef Operand	MemOperand
typedef int(*	regexp_matcher )(String *, int, const byte *, const byte *, int *, int, Address, int, Isolate *)
typedef unibrow::Mapping < unibrow::Ecma262Canonicalize >	Canonicalize
typedef void *	ExternalReferenceRedirectorPointer ()
typedef List< HeapObject * >	DebugObjectCache
typedef bool	EmitCharacterFunction (Isolate *isolate, RegExpCompiler *compiler, uc16 c, Label *on_failure, int cp_offset, bool check, bool preloaded)
typedef TypeImpl< HeapTypeConfig >	HeapType
typedef List< Map * >	MapList
typedef List< Code * >	CodeList
typedef List< Handle< Map > >	MapHandleList
typedef List< Handle< HeapType > >	TypeHandleList
typedef List< Handle< Code > >	CodeHandleList
typedef StringTableCleaner< false >	InternalizedStringTableCleaner
typedef StringTableCleaner< true >	ExternalStringTableCleaner
typedef bool(*	IsAliveFunction )(HeapObject *obj, int *size, int *offset)
typedef FPURegister	FloatRegister
typedef int(*	mips_regexp_matcher )(String *, int, const byte *, const byte *, void *, int *, int, Address, int, Isolate *)
typedef bool(*	NativeSourceCallback )(Vector< const char > name, Vector< const char > source, int index)
typedef NativesCollection< CORE >	Natives
typedef NativesCollection < EXPERIMENTAL >	ExperimentalNatives
typedef int	ExtraICState
typedef AtomicWord	OnceType
typedef void(*	NoArgFunction )()
typedef void(*	PointerArgFunction )(void *arg)
typedef LazyStaticInstance < ConditionVariable, DefaultConstructTrait < ConditionVariable > , ThreadSafeInitOnceTrait > ::type	LazyConditionVariable
typedef LazyStaticInstance < Mutex, DefaultConstructTrait < Mutex > , ThreadSafeInitOnceTrait > ::type	LazyMutex
typedef LazyStaticInstance < RecursiveMutex, DefaultConstructTrait < RecursiveMutex > , ThreadSafeInitOnceTrait > ::type	LazyRecursiveMutex
typedef IN PSTR	UserSearchPath
typedef IN PSTR IN BOOL	fInvadeProcess
typedef OUT PSTR	SearchPath
typedef OUT PSTR IN DWORD	SearchPathLength
typedef IN HANDLE	hFile
typedef IN HANDLE IN PSTR	ImageName
typedef IN HANDLE IN PSTR IN PSTR	ModuleName
typedef IN HANDLE IN PSTR IN PSTR IN DWORD64	BaseOfDll
typedef IN HANDLE IN PSTR IN PSTR IN DWORD64 IN DWORD	SizeOfDll
typedef HANDLE	hProcess
typedef HANDLE HANDLE	hThread
typedef HANDLE HANDLE LPSTACKFRAME64	StackFrame
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID	ContextRecord
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64	ReadMemoryRoutine
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64	FunctionTableAccessRoutine
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64	GetModuleBaseRoutine
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64 PTRANSLATE_ADDRESS_ROUTINE64	TranslateAddress
typedef IN DWORD64	qwAddr
typedef IN DWORD64 OUT PDWORD64	pdwDisplacement
typedef IN DWORD64 OUT PDWORD64 OUT PIMAGEHLP_SYMBOL64	Symbol
typedef IN DWORD64 OUT PDWORD OUT PIMAGEHLP_LINE64	Line64
typedef DWORD64	AddrBase
typedef DWORD	th32ProcessID
typedef LPMODULEENTRY32W	lpme
typedef TypeImpl< ZoneTypeConfig >	Type
typedef BitField< int, 0, kStringBuilderConcatHelperLengthBits >	StringBuilderSubstringLength
typedef BitField< int, kStringBuilderConcatHelperLengthBits, kStringBuilderConcatHelperPositionBits >	StringBuilderSubstringPosition
typedef uint64_t	ObjectPair
typedef void(*	ObjectSlotCallback )(HeapObject **from, HeapObject *to)
typedef void(StoreBuffer::*	RegionCallback )(Address start, Address end, ObjectSlotCallback slot_callback, bool clear_maps)
typedef BoundsImpl < ZoneTypeConfig >	Bounds
typedef bool(*	WeakSlotCallback )(Object **pointer)
typedef bool(*	WeakSlotCallbackWithHeap )(Heap *heap, Object **pointer)
typedef int(*	HeapObjectCallback )(HeapObject *obj)
typedef bool(*	ConstraintCallback )(Address new_addr, Address old_addr)
typedef void(*	InlineCacheCallback )(Code *code, Address ic)
typedef void(*	StoreBufferCallback )(Heap *heap, MemoryChunk *page, StoreBufferEvent event)
typedef zone_allocator< int >	ZoneIntAllocator
typedef std::vector< int, ZoneIntAllocator >	IntVector
typedef IntVector::iterator	IntVectorIter
typedef IntVector::reverse_iterator	IntVectorRIter
typedef TemplateHashMapImpl < ZoneAllocationPolicy >	ZoneHashMap

Enumerations
enum	Coprocessor {   p0 = 0, p1 = 1, p2 = 2, p3 = 3,   p4 = 4, p5 = 5, p6 = 6, p7 = 7,   p8 = 8, p9 = 9, p10 = 10, p11 = 11,   p12 = 12, p13 = 13, p14 = 14, p15 = 15 }
enum	TypeofState {   INSIDE_TYPEOF, NOT_INSIDE_TYPEOF, INSIDE_TYPEOF, NOT_INSIDE_TYPEOF,   INSIDE_TYPEOF, NOT_INSIDE_TYPEOF }
enum	Condition {   kNoCondition = -1, eq = 0 << 28, ne = 1 << 28, cs = 2 << 28,   cc = 3 << 28, mi = 4 << 28, pl = 5 << 28, vs = 6 << 28,   vc = 7 << 28, hi = 8 << 28, ls = 9 << 28, ge = 10 << 28,   lt = 11 << 28, gt = 12 << 28, le = 13 << 28, al = 14 << 28,   kSpecialCondition = 15 << 28, kNumberOfConditions = 16, hs = cs, lo = cc,   eq = 0 << 28, ne = 1 << 28, hs = cs, lo = cc,   mi = 4 << 28, pl = 5 << 28, vs = 6 << 28, vc = 7 << 28,   hi = 8 << 28, ls = 9 << 28, ge = 10 << 28, lt = 11 << 28,   gt = 12 << 28, le = 13 << 28, al = 14 << 28, nv = 15,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, carry = below, not_carry = above_equal, zero = equal,   not_zero = not_equal, sign = negative, not_sign = positive, kNoCondition = -1,   overflow = 0, no_overflow = 1, Uless = 2, Ugreater_equal = 3,   equal = 4, not_equal = 5, Uless_equal = 6, Ugreater = 7,   negative = 8, positive = 9, parity_even = 10, parity_odd = 11,   less = 12, greater_equal = 13, less_equal = 14, greater = 15,   ueq = 16, nue = 17, cc_always = 18, carry = below,   not_carry = above_equal, zero = equal, eq = 0 << 28, not_zero = not_equal,   ne = 1 << 28, nz = not_equal, sign = negative, not_sign = positive,   mi = 4 << 28, pl = 5 << 28, hi = 8 << 28, ls = 9 << 28,   ge = 10 << 28, lt = 11 << 28, gt = 12 << 28, le = 13 << 28,   hs = cs, lo = cc, al = 14 << 28, cc_default = kNoCondition,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, always = 16, never = 17, carry = below,   not_carry = above_equal, zero = equal, not_zero = not_equal, sign = negative,   not_sign = positive, last_condition = greater }
enum	Opcode {   AND = 0 << 21, EOR = 1 << 21, SUB = 2 << 21, RSB = 3 << 21,   ADD = 4 << 21, ADC = 5 << 21, SBC = 6 << 21, RSC = 7 << 21,   TST = 8 << 21, TEQ = 9 << 21, CMP = 10 << 21, CMN = 11 << 21,   ORR = 12 << 21, MOV = 13 << 21, BIC = 14 << 21, MVN = 15 << 21,   SPECIAL = 0 << kOpcodeShift, REGIMM = 1 << kOpcodeShift, J = ((0 << 3) + 2) << kOpcodeShift, JAL = ((0 << 3) + 3) << kOpcodeShift,   BEQ = ((0 << 3) + 4) << kOpcodeShift, BNE = ((0 << 3) + 5) << kOpcodeShift, BLEZ = ((0 << 3) + 6) << kOpcodeShift, BGTZ = ((0 << 3) + 7) << kOpcodeShift,   ADDI = ((1 << 3) + 0) << kOpcodeShift, ADDIU = ((1 << 3) + 1) << kOpcodeShift, SLTI = ((1 << 3) + 2) << kOpcodeShift, SLTIU = ((1 << 3) + 3) << kOpcodeShift,   ANDI = ((1 << 3) + 4) << kOpcodeShift, ORI = ((1 << 3) + 5) << kOpcodeShift, XORI = ((1 << 3) + 6) << kOpcodeShift, LUI = ((1 << 3) + 7) << kOpcodeShift,   COP1 = ((2 << 3) + 1) << kOpcodeShift, BEQL = ((2 << 3) + 4) << kOpcodeShift, BNEL = ((2 << 3) + 5) << kOpcodeShift, BLEZL = ((2 << 3) + 6) << kOpcodeShift,   BGTZL = ((2 << 3) + 7) << kOpcodeShift, SPECIAL2 = ((3 << 3) + 4) << kOpcodeShift, SPECIAL3 = ((3 << 3) + 7) << kOpcodeShift, LB = ((4 << 3) + 0) << kOpcodeShift,   LH = ((4 << 3) + 1) << kOpcodeShift, LWL = ((4 << 3) + 2) << kOpcodeShift, LW = ((4 << 3) + 3) << kOpcodeShift, LBU = ((4 << 3) + 4) << kOpcodeShift,   LHU = ((4 << 3) + 5) << kOpcodeShift, LWR = ((4 << 3) + 6) << kOpcodeShift, SB = ((5 << 3) + 0) << kOpcodeShift, SH = ((5 << 3) + 1) << kOpcodeShift,   SWL = ((5 << 3) + 2) << kOpcodeShift, SW = ((5 << 3) + 3) << kOpcodeShift, SWR = ((5 << 3) + 6) << kOpcodeShift, LWC1 = ((6 << 3) + 1) << kOpcodeShift,   LDC1 = ((6 << 3) + 5) << kOpcodeShift, PREF = ((6 << 3) + 3) << kOpcodeShift, SWC1 = ((7 << 3) + 1) << kOpcodeShift, SDC1 = ((7 << 3) + 5) << kOpcodeShift,   COP1X = ((1 << 4) + 3) << kOpcodeShift }
enum	MiscInstructionsBits74 {   BX = 1 << 4, BXJ = 2 << 4, BLX = 3 << 4, BKPT = 7 << 4,   CLZ = 1 << 4 }
enum	{   H = 1 << 5, S6 = 1 << 6, L = 1 << 20, S = 1 << 20,   W = 1 << 21, A = 1 << 21, B = 1 << 22, N = 1 << 22,   U = 1 << 23, P = 1 << 24, I = 1 << 25, B4 = 1 << 4,   B5 = 1 << 5, B6 = 1 << 6, B7 = 1 << 7, B8 = 1 << 8,   B9 = 1 << 9, B12 = 1 << 12, B16 = 1 << 16, B18 = 1 << 18,   B19 = 1 << 19, B20 = 1 << 20, B21 = 1 << 21, B22 = 1 << 22,   B23 = 1 << 23, B24 = 1 << 24, B25 = 1 << 25, B26 = 1 << 26,   B27 = 1 << 27, B28 = 1 << 28, kCondMask = 15 << 28, kALUMask = 0x6f << 21,   kRdMask = 15 << 12, kCoprocessorMask = 15 << 8, kOpCodeMask = 15 << 21, kImm24Mask = (1 << 24) - 1,   kImm16Mask = (1 << 16) - 1, kImm8Mask = (1 << 8) - 1, kOff12Mask = (1 << 12) - 1, kOff8Mask = (1 << 8) - 1 }
enum	SBit { SetCC = 1 << 20, LeaveCC = 0 << 20 }
enum	SRegister { CPSR = 0 << 22, SPSR = 1 << 22 }
enum	ShiftOp {   LSL = 0 << 5, LSR = 1 << 5, ASR = 2 << 5, ROR = 3 << 5,   RRX = -1, kNumberOfShifts = 4 }
enum	SRegisterField {   CPSR_c = CPSR | 1 << 16, CPSR_x = CPSR | 1 << 17, CPSR_s = CPSR | 1 << 18, CPSR_f = CPSR | 1 << 19,   SPSR_c = SPSR | 1 << 16, SPSR_x = SPSR | 1 << 17, SPSR_s = SPSR | 1 << 18, SPSR_f = SPSR | 1 << 19 }
enum	AddrMode {   Offset = (8|4|0) << 21, PreIndex = (8|4|1) << 21, PostIndex = (0|4|0) << 21, NegOffset = (8|0|0) << 21,   NegPreIndex = (8|0|1) << 21, NegPostIndex = (0|0|0) << 21, Offset = (8|4|0) << 21, PreIndex = (8|4|1) << 21,   PostIndex = (0|4|0) << 21 }
enum	BlockAddrMode {   da = (0|0|0) << 21, ia = (0|4|0) << 21, db = (8|0|0) << 21, ib = (8|4|0) << 21,   da_w = (0|0|1) << 21, ia_w = (0|4|1) << 21, db_w = (8|0|1) << 21, ib_w = (8|4|1) << 21,   da_x = (0|0|0) << 21, ia_x = (0|4|0) << 21, db_x = (8|0|0) << 21, ib_x = (8|4|0) << 21,   kBlockAddrModeMask = (8|4|1) << 21 }
enum	LFlag { Long = 1 << 22, Short = 0 << 22 }
enum	NeonDataType {   NeonS8 = 0x1, NeonS16 = 0x2, NeonS32 = 0x4, NeonU8 = 1 << 24 | 0x1,   NeonU16 = 1 << 24 | 0x2, NeonU32 = 1 << 24 | 0x4, NeonDataTypeSizeMask = 0x7, NeonDataTypeUMask = 1 << 24 }
enum	NeonListType { nlt_1 = 0x7, nlt_2 = 0xA, nlt_3 = 0x6, nlt_4 = 0x2 }
enum	NeonSize { Neon8 = 0x0, Neon16 = 0x1, Neon32 = 0x2, Neon64 = 0x3 }
enum	SoftwareInterruptCodes { kCallRtRedirected = 0x10, kBreakpoint = 0x20, kStopCode = 1 << 23, call_rt_redirected = 0xfffff }
enum	VFPRegPrecision { kSinglePrecision = 0, kDoublePrecision = 1 }
enum	VFPConversionMode { kFPSCRRounding = 0, kDefaultRoundToZero = 1 }
enum	VFPRoundingMode {   RN = 0 << 22, RP = 1 << 22, RM = 2 << 22, RZ = 3 << 22,   kRoundToNearest = RN, kRoundToPlusInf = RP, kRoundToMinusInf = RM, kRoundToZero = RZ }
enum	CheckForInexactConversion { kCheckForInexactConversion, kDontCheckForInexactConversion, kCheckForInexactConversion, kDontCheckForInexactConversion }
enum	Hint { no_hint = 0, no_hint = 0 }
enum	TaggingMode { TAG_RESULT, DONT_TAG_RESULT, TAG_RESULT, DONT_TAG_RESULT }
enum	RememberedSetAction {   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET }
enum	SmiCheck {   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK }
enum	LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved, kLRHasNotBeenSaved, kLRHasBeenSaved }
enum	TargetAddressStorageMode { CAN_INLINE_TARGET_ADDRESS, NEVER_INLINE_TARGET_ADDRESS, CAN_INLINE_TARGET_ADDRESS, NEVER_INLINE_TARGET_ADDRESS }
enum	Condition {   kNoCondition = -1, eq = 0 << 28, ne = 1 << 28, cs = 2 << 28,   cc = 3 << 28, mi = 4 << 28, pl = 5 << 28, vs = 6 << 28,   vc = 7 << 28, hi = 8 << 28, ls = 9 << 28, ge = 10 << 28,   lt = 11 << 28, gt = 12 << 28, le = 13 << 28, al = 14 << 28,   kSpecialCondition = 15 << 28, kNumberOfConditions = 16, hs = cs, lo = cc,   eq = 0 << 28, ne = 1 << 28, hs = cs, lo = cc,   mi = 4 << 28, pl = 5 << 28, vs = 6 << 28, vc = 7 << 28,   hi = 8 << 28, ls = 9 << 28, ge = 10 << 28, lt = 11 << 28,   gt = 12 << 28, le = 13 << 28, al = 14 << 28, nv = 15,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, carry = below, not_carry = above_equal, zero = equal,   not_zero = not_equal, sign = negative, not_sign = positive, kNoCondition = -1,   overflow = 0, no_overflow = 1, Uless = 2, Ugreater_equal = 3,   equal = 4, not_equal = 5, Uless_equal = 6, Ugreater = 7,   negative = 8, positive = 9, parity_even = 10, parity_odd = 11,   less = 12, greater_equal = 13, less_equal = 14, greater = 15,   ueq = 16, nue = 17, cc_always = 18, carry = below,   not_carry = above_equal, zero = equal, eq = 0 << 28, not_zero = not_equal,   ne = 1 << 28, nz = not_equal, sign = negative, not_sign = positive,   mi = 4 << 28, pl = 5 << 28, hi = 8 << 28, ls = 9 << 28,   ge = 10 << 28, lt = 11 << 28, gt = 12 << 28, le = 13 << 28,   hs = cs, lo = cc, al = 14 << 28, cc_default = kNoCondition,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, always = 16, never = 17, carry = below,   not_carry = above_equal, zero = equal, not_zero = not_equal, sign = negative,   not_sign = positive, last_condition = greater }
enum	FlagsUpdate { SetFlags = 1, LeaveFlags = 0 }
enum	StatusFlags {   NoFlag = 0, NFlag = N_mask, ZFlag = Z_mask, CFlag = C_mask,   VFlag = V_mask, NZFlag = NFlag | ZFlag, NCFlag = NFlag | CFlag, NVFlag = NFlag | VFlag,   ZCFlag = ZFlag | CFlag, ZVFlag = ZFlag | VFlag, CVFlag = CFlag | VFlag, NZCFlag = NFlag | ZFlag | CFlag,   NZVFlag = NFlag | ZFlag | VFlag, NCVFlag = NFlag | CFlag | VFlag, ZCVFlag = ZFlag | CFlag | VFlag, NZCVFlag = NFlag | ZFlag | CFlag | VFlag,   FPEqualFlag = ZCFlag, FPLessThanFlag = NFlag, FPGreaterThanFlag = CFlag, FPUnorderedFlag = CVFlag }
enum	Shift {   NO_SHIFT = -1, LSL = 0 << 5, LSR = 1 << 5, ASR = 2 << 5,   ROR = 3 << 5 }
enum	Extend {   NO_EXTEND = -1, UXTB = 0, UXTH = 1, UXTW = 2,   UXTX = 3, SXTB = 4, SXTH = 5, SXTW = 6,   SXTX = 7 }
enum	SystemHint {   NOP = 0, YIELD = 1, WFE = 2, WFI = 3,   SEV = 4, SEVL = 5 }
enum	BarrierDomain { OuterShareable = 0, NonShareable = 1, InnerShareable = 2, FullSystem = 3 }
enum	BarrierType { BarrierOther = 0, BarrierReads = 1, BarrierWrites = 2, BarrierAll = 3 }
enum	SystemRegister { NZCV, FPCR }
enum	GenericInstrField { SixtyFourBits = 0x80000000, ThirtyTwoBits = 0x00000000, FP32 = 0x00000000, FP64 = 0x00400000 }
enum	PCRelAddressingOp {   PCRelAddressingFixed = 0x10000000, PCRelAddressingFMask = 0x1F000000, PCRelAddressingMask = 0x9F000000, ADR = PCRelAddressingFixed | 0x00000000,   ADRP = PCRelAddressingFixed | 0x80000000 }
enum	AddSubOp {   AddSubOpMask = 0x60000000, AddSubSetFlagsBit = 0x20000000, ADD = 4 << 21, ADDS = ADD | AddSubSetFlagsBit,   SUB = 2 << 21, SUBS = SUB | AddSubSetFlagsBit }
enum	AddSubImmediateOp { AddSubImmediateFixed = 0x11000000, AddSubImmediateFMask = 0x1F000000, AddSubImmediateMask = 0xFF000000 }
enum	AddSubShiftedOp { AddSubShiftedFixed = 0x0B000000, AddSubShiftedFMask = 0x1F200000, AddSubShiftedMask = 0xFF200000 }
enum	AddSubExtendedOp { AddSubExtendedFixed = 0x0B200000, AddSubExtendedFMask = 0x1F200000, AddSubExtendedMask = 0xFFE00000 }
enum	AddSubWithCarryOp {   AddSubWithCarryFixed = 0x1A000000, AddSubWithCarryFMask = 0x1FE00000, AddSubWithCarryMask = 0xFFE0FC00, ADC_w = AddSubWithCarryFixed | ADD,   ADC_x = AddSubWithCarryFixed | ADD | SixtyFourBits, ADC = 5 << 21, ADCS_w = AddSubWithCarryFixed | ADDS, ADCS_x = AddSubWithCarryFixed | ADDS | SixtyFourBits,   SBC_w = AddSubWithCarryFixed | SUB, SBC_x = AddSubWithCarryFixed | SUB | SixtyFourBits, SBC = 6 << 21, SBCS_w = AddSubWithCarryFixed | SUBS,   SBCS_x = AddSubWithCarryFixed | SUBS | SixtyFourBits }
enum	LogicalOp {   LogicalOpMask = 0x60200000, NOT = 0x00200000, AND = 0 << 21, BIC = 14 << 21,   ORR = 12 << 21, ORN = ORR | NOT, EOR = 1 << 21, EON = EOR | NOT,   ANDS = 0x60000000, BICS = ANDS | NOT }
enum	LogicalImmediateOp {   LogicalImmediateFixed = 0x12000000, LogicalImmediateFMask = 0x1F800000, LogicalImmediateMask = 0xFF800000, AND_w_imm = LogicalImmediateFixed | AND,   AND_x_imm = LogicalImmediateFixed | AND | SixtyFourBits, ORR_w_imm = LogicalImmediateFixed | ORR, ORR_x_imm = LogicalImmediateFixed | ORR | SixtyFourBits, EOR_w_imm = LogicalImmediateFixed | EOR,   EOR_x_imm = LogicalImmediateFixed | EOR | SixtyFourBits, ANDS_w_imm = LogicalImmediateFixed | ANDS, ANDS_x_imm = LogicalImmediateFixed | ANDS | SixtyFourBits }
enum	LogicalShiftedOp {   LogicalShiftedFixed = 0x0A000000, LogicalShiftedFMask = 0x1F000000, LogicalShiftedMask = 0xFF200000, AND_w = LogicalShiftedFixed | AND,   AND_x = LogicalShiftedFixed | AND | SixtyFourBits, AND_shift = AND_w, BIC_w = LogicalShiftedFixed | BIC, BIC_x = LogicalShiftedFixed | BIC | SixtyFourBits,   BIC_shift = BIC_w, ORR_w = LogicalShiftedFixed | ORR, ORR_x = LogicalShiftedFixed | ORR | SixtyFourBits, ORR_shift = ORR_w,   ORN_w = LogicalShiftedFixed | ORN, ORN_x = LogicalShiftedFixed | ORN | SixtyFourBits, ORN_shift = ORN_w, EOR_w = LogicalShiftedFixed | EOR,   EOR_x = LogicalShiftedFixed | EOR | SixtyFourBits, EOR_shift = EOR_w, EON_w = LogicalShiftedFixed | EON, EON_x = LogicalShiftedFixed | EON | SixtyFourBits,   EON_shift = EON_w, ANDS_w = LogicalShiftedFixed | ANDS, ANDS_x = LogicalShiftedFixed | ANDS | SixtyFourBits, ANDS_shift = ANDS_w,   BICS_w = LogicalShiftedFixed | BICS, BICS_x = LogicalShiftedFixed | BICS | SixtyFourBits, BICS_shift = BICS_w }
enum	MoveWideImmediateOp {   MoveWideImmediateFixed = 0x12800000, MoveWideImmediateFMask = 0x1F800000, MoveWideImmediateMask = 0xFF800000, MOVN = 0x00000000,   MOVZ = 0x40000000, MOVK = 0x60000000, MOVN_w = MoveWideImmediateFixed | MOVN, MOVN_x = MoveWideImmediateFixed | MOVN | SixtyFourBits,   MOVZ_w = MoveWideImmediateFixed | MOVZ, MOVZ_x = MoveWideImmediateFixed | MOVZ | SixtyFourBits, MOVK_w = MoveWideImmediateFixed | MOVK, MOVK_x = MoveWideImmediateFixed | MOVK | SixtyFourBits }
enum	BitfieldOp {   BitfieldFixed = 0x13000000, BitfieldFMask = 0x1F800000, BitfieldMask = 0xFF800000, SBFM_w = BitfieldFixed | 0x00000000,   SBFM_x = BitfieldFixed | 0x80000000, SBFM = SBFM_w, BFM_w = BitfieldFixed | 0x20000000, BFM_x = BitfieldFixed | 0xA0000000,   BFM = BFM_w, UBFM_w = BitfieldFixed | 0x40000000, UBFM_x = BitfieldFixed | 0xC0000000, UBFM = UBFM_w }
enum	ExtractOp {   ExtractFixed = 0x13800000, ExtractFMask = 0x1F800000, ExtractMask = 0xFFA00000, EXTR_w = ExtractFixed | 0x00000000,   EXTR_x = ExtractFixed | 0x80000000, EXTR = EXTR_w }
enum	UnconditionalBranchOp {   UnconditionalBranchFixed = 0x14000000, UnconditionalBranchFMask = 0x7C000000, UnconditionalBranchMask = 0xFC000000, B = 1 << 22,   BL = UnconditionalBranchFixed | 0x80000000 }
enum	UnconditionalBranchToRegisterOp {   UnconditionalBranchToRegisterFixed = 0xD6000000, UnconditionalBranchToRegisterFMask = 0xFE000000, UnconditionalBranchToRegisterMask = 0xFFFFFC1F, BR = UnconditionalBranchToRegisterFixed | 0x001F0000,   BLR = UnconditionalBranchToRegisterFixed | 0x003F0000, RET = UnconditionalBranchToRegisterFixed | 0x005F0000 }
enum	CompareBranchOp {   CompareBranchFixed = 0x34000000, CompareBranchFMask = 0x7E000000, CompareBranchMask = 0xFF000000, CBZ_w = CompareBranchFixed | 0x00000000,   CBZ_x = CompareBranchFixed | 0x80000000, CBZ = CBZ_w, CBNZ_w = CompareBranchFixed | 0x01000000, CBNZ_x = CompareBranchFixed | 0x81000000,   CBNZ = CBNZ_w }
enum	TestBranchOp {   TestBranchFixed = 0x36000000, TestBranchFMask = 0x7E000000, TestBranchMask = 0x7F000000, TBZ = TestBranchFixed | 0x00000000,   TBNZ = TestBranchFixed | 0x01000000 }
enum	ConditionalBranchOp { ConditionalBranchFixed = 0x54000000, ConditionalBranchFMask = 0xFE000000, ConditionalBranchMask = 0xFF000010, B_cond = ConditionalBranchFixed | 0x00000000 }
enum	SystemOp { SystemFixed = 0xD5000000, SystemFMask = 0xFFC00000 }
enum	SystemSysRegOp {   SystemSysRegFixed = 0xD5100000, SystemSysRegFMask = 0xFFD00000, SystemSysRegMask = 0xFFF00000, MRS = SystemSysRegFixed | 0x00200000,   MSR = SystemSysRegFixed | 0x00000000 }
enum	SystemHintOp { SystemHintFixed = 0xD503201F, SystemHintFMask = 0xFFFFF01F, SystemHintMask = 0xFFFFF01F, HINT = SystemHintFixed | 0x00000000 }
enum	ExceptionOp {   ExceptionFixed = 0xD4000000, ExceptionFMask = 0xFF000000, ExceptionMask = 0xFFE0001F, HLT = ExceptionFixed | 0x00400000,   BRK = ExceptionFixed | 0x00200000, SVC = ExceptionFixed | 0x00000001, HVC = ExceptionFixed | 0x00000002, SMC = ExceptionFixed | 0x00000003,   DCPS1 = ExceptionFixed | 0x00A00001, DCPS2 = ExceptionFixed | 0x00A00002, DCPS3 = ExceptionFixed | 0x00A00003 }
enum	MemBarrierOp {   MemBarrierFixed = 0xD503309F, MemBarrierFMask = 0xFFFFF09F, MemBarrierMask = 0xFFFFF0FF, DSB = MemBarrierFixed | 0x00000000,   DMB = MemBarrierFixed | 0x00000020, ISB = MemBarrierFixed | 0x00000040 }
enum	LoadStoreAnyOp { LoadStoreAnyFMask = 0x0a000000, LoadStoreAnyFixed = 0x08000000 }
enum	LoadStorePairAnyOp { LoadStorePairAnyFMask = 0x3a000000, LoadStorePairAnyFixed = 0x28000000 }
enum	LoadStorePairOp { LoadStorePairMask = 0xC4400000, LoadStorePairLBit = 1 << 22 }
enum	LoadStorePairPostIndexOp { LoadStorePairPostIndexFixed = 0x28800000, LoadStorePairPostIndexFMask = 0x3B800000, LoadStorePairPostIndexMask = 0xFFC00000 }
enum	LoadStorePairPreIndexOp { LoadStorePairPreIndexFixed = 0x29800000, LoadStorePairPreIndexFMask = 0x3B800000, LoadStorePairPreIndexMask = 0xFFC00000 }
enum	LoadStorePairOffsetOp { LoadStorePairOffsetFixed = 0x29000000, LoadStorePairOffsetFMask = 0x3B800000, LoadStorePairOffsetMask = 0xFFC00000 }
enum	LoadStorePairNonTemporalOp {   LoadStorePairNonTemporalFixed = 0x28000000, LoadStorePairNonTemporalFMask = 0x3B800000, LoadStorePairNonTemporalMask = 0xFFC00000, STNP_w = LoadStorePairNonTemporalFixed | STP_w,   LDNP_w = LoadStorePairNonTemporalFixed | LDP_w, STNP_x = LoadStorePairNonTemporalFixed | STP_x, LDNP_x = LoadStorePairNonTemporalFixed | LDP_x, STNP_s = LoadStorePairNonTemporalFixed | STP_s,   LDNP_s = LoadStorePairNonTemporalFixed | LDP_s, STNP_d = LoadStorePairNonTemporalFixed | STP_d, LDNP_d = LoadStorePairNonTemporalFixed | LDP_d }
enum	LoadLiteralOp {   LoadLiteralFixed = 0x18000000, LoadLiteralFMask = 0x3B000000, LoadLiteralMask = 0xFF000000, LDR_w_lit = LoadLiteralFixed | 0x00000000,   LDR_x_lit = LoadLiteralFixed | 0x40000000, LDRSW_x_lit = LoadLiteralFixed | 0x80000000, PRFM_lit = LoadLiteralFixed | 0xC0000000, LDR_s_lit = LoadLiteralFixed | 0x04000000,   LDR_d_lit = LoadLiteralFixed | 0x44000000 }
enum	LoadStoreUnscaledOffsetOp { LoadStoreUnscaledOffsetFixed = 0x38000000, LoadStoreUnscaledOffsetFMask = 0x3B200C00, LoadStoreUnscaledOffsetMask = 0xFFE00C00 }
enum	LoadStoreOp { LoadStoreOpMask = 0xC4C00000, LOAD_STORE_OP_LIST =(LOAD_STORE), PRFM = 0xC0800000 }
enum	LoadStorePostIndex { LoadStorePostIndexFixed = 0x38000400, LoadStorePostIndexFMask = 0x3B200C00, LoadStorePostIndexMask = 0xFFE00C00 }
enum	LoadStorePreIndex { LoadStorePreIndexFixed = 0x38000C00, LoadStorePreIndexFMask = 0x3B200C00, LoadStorePreIndexMask = 0xFFE00C00 }
enum	LoadStoreUnsignedOffset { LoadStoreUnsignedOffsetFixed = 0x39000000, LoadStoreUnsignedOffsetFMask = 0x3B000000, LoadStoreUnsignedOffsetMask = 0xFFC00000, PRFM_unsigned = LoadStoreUnsignedOffsetFixed | PRFM }
enum	LoadStoreRegisterOffset { LoadStoreRegisterOffsetFixed = 0x38200800, LoadStoreRegisterOffsetFMask = 0x3B200C00, LoadStoreRegisterOffsetMask = 0xFFE00C00, PRFM_reg = LoadStoreRegisterOffsetFixed | PRFM }
enum	ConditionalCompareOp { ConditionalCompareMask = 0x60000000, CCMN = 0x20000000, CCMP = 0x60000000 }
enum	ConditionalCompareRegisterOp {   ConditionalCompareRegisterFixed = 0x1A400000, ConditionalCompareRegisterFMask = 0x1FE00800, ConditionalCompareRegisterMask = 0xFFE00C10, CCMN_w = ConditionalCompareRegisterFixed | CCMN,   CCMN_x = ConditionalCompareRegisterFixed | SixtyFourBits | CCMN, CCMP_w = ConditionalCompareRegisterFixed | CCMP, CCMP_x = ConditionalCompareRegisterFixed | SixtyFourBits | CCMP }
enum	ConditionalCompareImmediateOp {   ConditionalCompareImmediateFixed = 0x1A400800, ConditionalCompareImmediateFMask = 0x1FE00800, ConditionalCompareImmediateMask = 0xFFE00C10, CCMN_w_imm = ConditionalCompareImmediateFixed | CCMN,   CCMN_x_imm = ConditionalCompareImmediateFixed | SixtyFourBits | CCMN, CCMP_w_imm = ConditionalCompareImmediateFixed | CCMP, CCMP_x_imm = ConditionalCompareImmediateFixed | SixtyFourBits | CCMP }
enum	ConditionalSelectOp {   ConditionalSelectFixed = 0x1A800000, ConditionalSelectFMask = 0x1FE00000, ConditionalSelectMask = 0xFFE00C00, CSEL_w = ConditionalSelectFixed | 0x00000000,   CSEL_x = ConditionalSelectFixed | 0x80000000, CSEL = CSEL_w, CSINC_w = ConditionalSelectFixed | 0x00000400, CSINC_x = ConditionalSelectFixed | 0x80000400,   CSINC = CSINC_w, CSINV_w = ConditionalSelectFixed | 0x40000000, CSINV_x = ConditionalSelectFixed | 0xC0000000, CSINV = CSINV_w,   CSNEG_w = ConditionalSelectFixed | 0x40000400, CSNEG_x = ConditionalSelectFixed | 0xC0000400, CSNEG = CSNEG_w }
enum	DataProcessing1SourceOp {   DataProcessing1SourceFixed = 0x5AC00000, DataProcessing1SourceFMask = 0x5FE00000, DataProcessing1SourceMask = 0xFFFFFC00, RBIT = DataProcessing1SourceFixed | 0x00000000,   RBIT_w = RBIT, RBIT_x = RBIT | SixtyFourBits, REV16 = DataProcessing1SourceFixed | 0x00000400, REV16_w = REV16,   REV16_x = REV16 | SixtyFourBits, REV = DataProcessing1SourceFixed | 0x00000800, REV_w = REV, REV32_x = REV | SixtyFourBits,   REV_x = DataProcessing1SourceFixed | SixtyFourBits | 0x00000C00, CLZ = 1 << 4, CLZ_w = CLZ, CLZ_x = CLZ | SixtyFourBits,   CLS = DataProcessing1SourceFixed | 0x00001400, CLS_w = CLS, CLS_x = CLS | SixtyFourBits }
enum	DataProcessing2SourceOp {   DataProcessing2SourceFixed = 0x1AC00000, DataProcessing2SourceFMask = 0x5FE00000, DataProcessing2SourceMask = 0xFFE0FC00, UDIV_w = DataProcessing2SourceFixed | 0x00000800,   UDIV_x = DataProcessing2SourceFixed | 0x80000800, UDIV = UDIV_w, SDIV_w = DataProcessing2SourceFixed | 0x00000C00, SDIV_x = DataProcessing2SourceFixed | 0x80000C00,   SDIV = SDIV_w, LSLV_w = DataProcessing2SourceFixed | 0x00002000, LSLV_x = DataProcessing2SourceFixed | 0x80002000, LSLV = LSLV_w,   LSRV_w = DataProcessing2SourceFixed | 0x00002400, LSRV_x = DataProcessing2SourceFixed | 0x80002400, LSRV = LSRV_w, ASRV_w = DataProcessing2SourceFixed | 0x00002800,   ASRV_x = DataProcessing2SourceFixed | 0x80002800, ASRV = ASRV_w, RORV_w = DataProcessing2SourceFixed | 0x00002C00, RORV_x = DataProcessing2SourceFixed | 0x80002C00,   RORV = RORV_w, CRC32B = DataProcessing2SourceFixed | 0x00004000, CRC32H = DataProcessing2SourceFixed | 0x00004400, CRC32W = DataProcessing2SourceFixed | 0x00004800,   CRC32X = DataProcessing2SourceFixed | SixtyFourBits | 0x00004C00, CRC32CB = DataProcessing2SourceFixed | 0x00005000, CRC32CH = DataProcessing2SourceFixed | 0x00005400, CRC32CW = DataProcessing2SourceFixed | 0x00005800,   CRC32CX = DataProcessing2SourceFixed | SixtyFourBits | 0x00005C00 }
enum	DataProcessing3SourceOp {   DataProcessing3SourceFixed = 0x1B000000, DataProcessing3SourceFMask = 0x1F000000, DataProcessing3SourceMask = 0xFFE08000, MADD_w = DataProcessing3SourceFixed | 0x00000000,   MADD_x = DataProcessing3SourceFixed | 0x80000000, MADD = MADD_w, MSUB_w = DataProcessing3SourceFixed | 0x00008000, MSUB_x = DataProcessing3SourceFixed | 0x80008000,   MSUB = MSUB_w, SMADDL_x = DataProcessing3SourceFixed | 0x80200000, SMSUBL_x = DataProcessing3SourceFixed | 0x80208000, SMULH_x = DataProcessing3SourceFixed | 0x80400000,   UMADDL_x = DataProcessing3SourceFixed | 0x80A00000, UMSUBL_x = DataProcessing3SourceFixed | 0x80A08000, UMULH_x = DataProcessing3SourceFixed | 0x80C00000 }
enum	FPCompareOp {   FPCompareFixed = 0x1E202000, FPCompareFMask = 0x5F203C00, FPCompareMask = 0xFFE0FC1F, FCMP_s = FPCompareFixed | 0x00000000,   FCMP_d = FPCompareFixed | FP64 | 0x00000000, FCMP = FCMP_s, FCMP_s_zero = FPCompareFixed | 0x00000008, FCMP_d_zero = FPCompareFixed | FP64 | 0x00000008,   FCMP_zero = FCMP_s_zero, FCMPE_s = FPCompareFixed | 0x00000010, FCMPE_d = FPCompareFixed | FP64 | 0x00000010, FCMPE_s_zero = FPCompareFixed | 0x00000018,   FCMPE_d_zero = FPCompareFixed | FP64 | 0x00000018 }
enum	FPConditionalCompareOp {   FPConditionalCompareFixed = 0x1E200400, FPConditionalCompareFMask = 0x5F200C00, FPConditionalCompareMask = 0xFFE00C10, FCCMP_s = FPConditionalCompareFixed | 0x00000000,   FCCMP_d = FPConditionalCompareFixed | FP64 | 0x00000000, FCCMP = FCCMP_s, FCCMPE_s = FPConditionalCompareFixed | 0x00000010, FCCMPE_d = FPConditionalCompareFixed | FP64 | 0x00000010,   FCCMPE = FCCMPE_s }
enum	FPConditionalSelectOp {   FPConditionalSelectFixed = 0x1E200C00, FPConditionalSelectFMask = 0x5F200C00, FPConditionalSelectMask = 0xFFE00C00, FCSEL_s = FPConditionalSelectFixed | 0x00000000,   FCSEL_d = FPConditionalSelectFixed | FP64 | 0x00000000, FCSEL = FCSEL_s }
enum	FPImmediateOp {   FPImmediateFixed = 0x1E201000, FPImmediateFMask = 0x5F201C00, FPImmediateMask = 0xFFE01C00, FMOV_s_imm = FPImmediateFixed | 0x00000000,   FMOV_d_imm = FPImmediateFixed | FP64 | 0x00000000 }
enum	FPDataProcessing1SourceOp {   FPDataProcessing1SourceFixed = 0x1E204000, FPDataProcessing1SourceFMask = 0x5F207C00, FPDataProcessing1SourceMask = 0xFFFFFC00, FMOV_s = FPDataProcessing1SourceFixed | 0x00000000,   FMOV_d = FPDataProcessing1SourceFixed | FP64 | 0x00000000, FMOV = FMOV_s, FABS_s = FPDataProcessing1SourceFixed | 0x00008000, FABS_d = FPDataProcessing1SourceFixed | FP64 | 0x00008000,   FABS = FABS_s, FNEG_s = FPDataProcessing1SourceFixed | 0x00010000, FNEG_d = FPDataProcessing1SourceFixed | FP64 | 0x00010000, FNEG = FNEG_s,   FSQRT_s = FPDataProcessing1SourceFixed | 0x00018000, FSQRT_d = FPDataProcessing1SourceFixed | FP64 | 0x00018000, FSQRT = FSQRT_s, FCVT_ds = FPDataProcessing1SourceFixed | 0x00028000,   FCVT_sd = FPDataProcessing1SourceFixed | FP64 | 0x00020000, FRINTN_s = FPDataProcessing1SourceFixed | 0x00040000, FRINTN_d = FPDataProcessing1SourceFixed | FP64 | 0x00040000, FRINTN = FRINTN_s,   FRINTP_s = FPDataProcessing1SourceFixed | 0x00048000, FRINTP_d = FPDataProcessing1SourceFixed | FP64 | 0x00048000, FRINTP = FRINTP_s, FRINTM_s = FPDataProcessing1SourceFixed | 0x00050000,   FRINTM_d = FPDataProcessing1SourceFixed | FP64 | 0x00050000, FRINTM = FRINTM_s, FRINTZ_s = FPDataProcessing1SourceFixed | 0x00058000, FRINTZ_d = FPDataProcessing1SourceFixed | FP64 | 0x00058000,   FRINTZ = FRINTZ_s, FRINTA_s = FPDataProcessing1SourceFixed | 0x00060000, FRINTA_d = FPDataProcessing1SourceFixed | FP64 | 0x00060000, FRINTA = FRINTA_s,   FRINTX_s = FPDataProcessing1SourceFixed | 0x00070000, FRINTX_d = FPDataProcessing1SourceFixed | FP64 | 0x00070000, FRINTX = FRINTX_s, FRINTI_s = FPDataProcessing1SourceFixed | 0x00078000,   FRINTI_d = FPDataProcessing1SourceFixed | FP64 | 0x00078000, FRINTI = FRINTI_s }
enum	FPDataProcessing2SourceOp {   FPDataProcessing2SourceFixed = 0x1E200800, FPDataProcessing2SourceFMask = 0x5F200C00, FPDataProcessing2SourceMask = 0xFFE0FC00, FMUL = FPDataProcessing2SourceFixed | 0x00000000,   FMUL_s = FMUL, FMUL_d = FMUL | FP64, FDIV = FPDataProcessing2SourceFixed | 0x00001000, FDIV_s = FDIV,   FDIV_d = FDIV | FP64, FADD = FPDataProcessing2SourceFixed | 0x00002000, FADD_s = FADD, FADD_d = FADD | FP64,   FSUB = FPDataProcessing2SourceFixed | 0x00003000, FSUB_s = FSUB, FSUB_d = FSUB | FP64, FMAX = FPDataProcessing2SourceFixed | 0x00004000,   FMAX_s = FMAX, FMAX_d = FMAX | FP64, FMIN = FPDataProcessing2SourceFixed | 0x00005000, FMIN_s = FMIN,   FMIN_d = FMIN | FP64, FMAXNM = FPDataProcessing2SourceFixed | 0x00006000, FMAXNM_s = FMAXNM, FMAXNM_d = FMAXNM | FP64,   FMINNM = FPDataProcessing2SourceFixed | 0x00007000, FMINNM_s = FMINNM, FMINNM_d = FMINNM | FP64, FNMUL = FPDataProcessing2SourceFixed | 0x00008000,   FNMUL_s = FNMUL, FNMUL_d = FNMUL | FP64 }
enum	FPDataProcessing3SourceOp {   FPDataProcessing3SourceFixed = 0x1F000000, FPDataProcessing3SourceFMask = 0x5F000000, FPDataProcessing3SourceMask = 0xFFE08000, FMADD_s = FPDataProcessing3SourceFixed | 0x00000000,   FMSUB_s = FPDataProcessing3SourceFixed | 0x00008000, FNMADD_s = FPDataProcessing3SourceFixed | 0x00200000, FNMSUB_s = FPDataProcessing3SourceFixed | 0x00208000, FMADD_d = FPDataProcessing3SourceFixed | 0x00400000,   FMSUB_d = FPDataProcessing3SourceFixed | 0x00408000, FNMADD_d = FPDataProcessing3SourceFixed | 0x00600000, FNMSUB_d = FPDataProcessing3SourceFixed | 0x00608000 }
enum	FPIntegerConvertOp {   FPIntegerConvertFixed = 0x1E200000, FPIntegerConvertFMask = 0x5F20FC00, FPIntegerConvertMask = 0xFFFFFC00, FCVTNS = FPIntegerConvertFixed | 0x00000000,   FCVTNS_ws = FCVTNS, FCVTNS_xs = FCVTNS | SixtyFourBits, FCVTNS_wd = FCVTNS | FP64, FCVTNS_xd = FCVTNS | SixtyFourBits | FP64,   FCVTNU = FPIntegerConvertFixed | 0x00010000, FCVTNU_ws = FCVTNU, FCVTNU_xs = FCVTNU | SixtyFourBits, FCVTNU_wd = FCVTNU | FP64,   FCVTNU_xd = FCVTNU | SixtyFourBits | FP64, FCVTPS = FPIntegerConvertFixed | 0x00080000, FCVTPS_ws = FCVTPS, FCVTPS_xs = FCVTPS | SixtyFourBits,   FCVTPS_wd = FCVTPS | FP64, FCVTPS_xd = FCVTPS | SixtyFourBits | FP64, FCVTPU = FPIntegerConvertFixed | 0x00090000, FCVTPU_ws = FCVTPU,   FCVTPU_xs = FCVTPU | SixtyFourBits, FCVTPU_wd = FCVTPU | FP64, FCVTPU_xd = FCVTPU | SixtyFourBits | FP64, FCVTMS = FPIntegerConvertFixed | 0x00100000,   FCVTMS_ws = FCVTMS, FCVTMS_xs = FCVTMS | SixtyFourBits, FCVTMS_wd = FCVTMS | FP64, FCVTMS_xd = FCVTMS | SixtyFourBits | FP64,   FCVTMU = FPIntegerConvertFixed | 0x00110000, FCVTMU_ws = FCVTMU, FCVTMU_xs = FCVTMU | SixtyFourBits, FCVTMU_wd = FCVTMU | FP64,   FCVTMU_xd = FCVTMU | SixtyFourBits | FP64, FCVTZS = FPIntegerConvertFixed | 0x00180000, FCVTZS_ws = FCVTZS, FCVTZS_xs = FCVTZS | SixtyFourBits,   FCVTZS_wd = FCVTZS | FP64, FCVTZS_xd = FCVTZS | SixtyFourBits | FP64, FCVTZU = FPIntegerConvertFixed | 0x00190000, FCVTZU_ws = FCVTZU,   FCVTZU_xs = FCVTZU | SixtyFourBits, FCVTZU_wd = FCVTZU | FP64, FCVTZU_xd = FCVTZU | SixtyFourBits | FP64, SCVTF = FPIntegerConvertFixed | 0x00020000,   SCVTF_sw = SCVTF, SCVTF_sx = SCVTF | SixtyFourBits, SCVTF_dw = SCVTF | FP64, SCVTF_dx = SCVTF | SixtyFourBits | FP64,   UCVTF = FPIntegerConvertFixed | 0x00030000, UCVTF_sw = UCVTF, UCVTF_sx = UCVTF | SixtyFourBits, UCVTF_dw = UCVTF | FP64,   UCVTF_dx = UCVTF | SixtyFourBits | FP64, FCVTAS = FPIntegerConvertFixed | 0x00040000, FCVTAS_ws = FCVTAS, FCVTAS_xs = FCVTAS | SixtyFourBits,   FCVTAS_wd = FCVTAS | FP64, FCVTAS_xd = FCVTAS | SixtyFourBits | FP64, FCVTAU = FPIntegerConvertFixed | 0x00050000, FCVTAU_ws = FCVTAU,   FCVTAU_xs = FCVTAU | SixtyFourBits, FCVTAU_wd = FCVTAU | FP64, FCVTAU_xd = FCVTAU | SixtyFourBits | FP64, FMOV_ws = FPIntegerConvertFixed | 0x00060000,   FMOV_sw = FPIntegerConvertFixed | 0x00070000, FMOV_xd = FMOV_ws | SixtyFourBits | FP64, FMOV_dx = FMOV_sw | SixtyFourBits | FP64 }
enum	FPFixedPointConvertOp {   FPFixedPointConvertFixed = 0x1E000000, FPFixedPointConvertFMask = 0x5F200000, FPFixedPointConvertMask = 0xFFFF0000, FCVTZS_fixed = FPFixedPointConvertFixed | 0x00180000,   FCVTZS_ws_fixed = FCVTZS_fixed, FCVTZS_xs_fixed = FCVTZS_fixed | SixtyFourBits, FCVTZS_wd_fixed = FCVTZS_fixed | FP64, FCVTZS_xd_fixed = FCVTZS_fixed | SixtyFourBits | FP64,   FCVTZU_fixed = FPFixedPointConvertFixed | 0x00190000, FCVTZU_ws_fixed = FCVTZU_fixed, FCVTZU_xs_fixed = FCVTZU_fixed | SixtyFourBits, FCVTZU_wd_fixed = FCVTZU_fixed | FP64,   FCVTZU_xd_fixed = FCVTZU_fixed | SixtyFourBits | FP64, SCVTF_fixed = FPFixedPointConvertFixed | 0x00020000, SCVTF_sw_fixed = SCVTF_fixed, SCVTF_sx_fixed = SCVTF_fixed | SixtyFourBits,   SCVTF_dw_fixed = SCVTF_fixed | FP64, SCVTF_dx_fixed = SCVTF_fixed | SixtyFourBits | FP64, UCVTF_fixed = FPFixedPointConvertFixed | 0x00030000, UCVTF_sw_fixed = UCVTF_fixed,   UCVTF_sx_fixed = UCVTF_fixed | SixtyFourBits, UCVTF_dw_fixed = UCVTF_fixed | FP64, UCVTF_dx_fixed = UCVTF_fixed | SixtyFourBits | FP64 }
enum	UnimplementedOp { UnimplementedFixed = 0x00000000, UnimplementedFMask = 0x00000000 }
enum	UnallocatedOp { UnallocatedFixed = 0x00000000, UnallocatedFMask = 0x00000000 }
enum	LSDataSize { LSByte = 0, LSHalfword = 1, LSWord = 2, LSDoubleWord = 3 }
enum	ImmBranchType {   UnknownBranchType = 0, CondBranchType = 1, UncondBranchType = 2, CompareBranchType = 3,   TestBranchType = 4 }
enum	AddrMode {   Offset = (8|4|0) << 21, PreIndex = (8|4|1) << 21, PostIndex = (0|4|0) << 21, NegOffset = (8|0|0) << 21,   NegPreIndex = (8|0|1) << 21, NegPostIndex = (0|0|0) << 21, Offset = (8|4|0) << 21, PreIndex = (8|4|1) << 21,   PostIndex = (0|4|0) << 21 }
enum	FPRounding {   FPTieEven = 0x0, FPPositiveInfinity = 0x1, FPNegativeInfinity = 0x2, FPZero = 0x3,   FPTieAway }
enum	Reg31Mode { Reg31IsStackPointer, Reg31IsZeroRegister }
enum	DebugParameters {   NO_PARAM = 0, BREAK = 1 << 0, LOG_DISASM = 1 << 1, LOG_REGS = 1 << 2,   LOG_FP_REGS = 1 << 3, LOG_SYS_REGS = 1 << 4, LOG_WRITE = 1 << 5, LOG_STATE = LOG_REGS | LOG_FP_REGS | LOG_SYS_REGS,   LOG_ALL = LOG_DISASM | LOG_STATE | LOG_WRITE, TRACE_ENABLE = 1 << 6, TRACE_DISABLE = 2 << 6, TRACE_OVERRIDE = 3 << 6 }
enum	InstrumentState { InstrumentStateDisable = 0, InstrumentStateEnable = 1 }
enum	CounterType { Gauge = 0, Cumulative = 1 }
enum	BranchType {   integer_eq = eq, integer_ne = ne, integer_hs = hs, integer_lo = lo,   integer_mi = mi, integer_pl = pl, integer_vs = vs, integer_vc = vc,   integer_hi = hi, integer_ls = ls, integer_ge = ge, integer_lt = lt,   integer_gt = gt, integer_le = le, integer_al = al, integer_nv = nv,   always = 16, never = 17, reg_zero, reg_not_zero,   reg_bit_clear, reg_bit_set, kBranchTypeFirstCondition = eq, kBranchTypeLastCondition = nv,   kBranchTypeFirstUsingReg = reg_zero, kBranchTypeFirstUsingBit = reg_bit_clear }
enum	RememberedSetAction {   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET }
enum	SmiCheck {   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK }
enum	LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved, kLRHasNotBeenSaved, kLRHasBeenSaved }
enum	TargetAddressStorageMode { CAN_INLINE_TARGET_ADDRESS, NEVER_INLINE_TARGET_ADDRESS, CAN_INLINE_TARGET_ADDRESS, NEVER_INLINE_TARGET_ADDRESS }
enum	UntagMode { kNotSpeculativeUntag, kSpeculativeUntag }
enum	ArrayHasHoles { kArrayCantHaveHoles, kArrayCanHaveHoles }
enum	CopyHint { kCopyUnknown, kCopyShort, kCopyLong }
enum	DiscardMoveMode { kDontDiscardForSameWReg, kDiscardForSameWReg }
enum	SeqStringSetCharCheckIndexType { kIndexIsSmi, kIndexIsInteger32 }
enum	SaveFPRegsMode { kDontSaveFPRegs, kSaveFPRegs }
enum	PerThreadAssertType {   HEAP_ALLOCATION_ASSERT, HANDLE_ALLOCATION_ASSERT, HANDLE_DEREFERENCE_ASSERT, DEFERRED_HANDLE_DEREFERENCE_ASSERT,   CODE_DEPENDENCY_CHANGE_ASSERT, LAST_PER_THREAD_ASSERT_TYPE }
enum	PerIsolateAssertType { JAVASCRIPT_EXECUTION_ASSERT, JAVASCRIPT_EXECUTION_THROWS, ALLOCATION_FAILURE_ASSERT }
enum	AstPropertiesFlag { kDontInline, kDontSelfOptimize, kDontSoftInline, kDontCache }
enum	__tsan_memory_order {   __tsan_memory_order_relaxed, __tsan_memory_order_consume, __tsan_memory_order_acquire, __tsan_memory_order_release,   __tsan_memory_order_acq_rel, __tsan_memory_order_seq_cst }
enum	BignumDtoaMode { BIGNUM_DTOA_SHORTEST, BIGNUM_DTOA_FIXED, BIGNUM_DTOA_PRECISION }
enum	BuiltinExtraArguments { NO_EXTRA_ARGUMENTS = 0, NEEDS_CALLED_FUNCTION = 1 }
enum	StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE }
enum	HandlerArgumentsMode { DONT_PASS_ARGUMENTS, PASS_ARGUMENTS }
enum	AllocationSiteOverrideMode { DONT_OVERRIDE, DISABLE_ALLOCATION_SITES, LAST_ALLOCATION_SITE_OVERRIDE_MODE = DISABLE_ALLOCATION_SITES }
enum	StringAddFlags { STRING_ADD_CHECK_NONE = 0, STRING_ADD_CHECK_LEFT = 1 << 0, STRING_ADD_CHECK_RIGHT = 1 << 1, STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT }
enum	StringIndexFlags { STRING_INDEX_IS_NUMBER, STRING_INDEX_IS_ARRAY_INDEX }
enum	ParseRestriction { NO_PARSE_RESTRICTION, ONLY_SINGLE_FUNCTION_LITERAL }
enum	CachedDataMode { NO_CACHED_DATA, CONSUME_CACHED_DATA, PRODUCE_CACHED_DATA }
enum	ContextLookupFlags { FOLLOW_CONTEXT_CHAIN = 1, FOLLOW_PROTOTYPE_CHAIN = 2, DONT_FOLLOW_CHAINS = 0, FOLLOW_CHAINS = FOLLOW_CONTEXT_CHAIN | FOLLOW_PROTOTYPE_CHAIN }
enum	BindingFlags {   MUTABLE_IS_INITIALIZED, MUTABLE_CHECK_INITIALIZED, IMMUTABLE_IS_INITIALIZED, IMMUTABLE_CHECK_INITIALIZED,   IMMUTABLE_IS_INITIALIZED_HARMONY, IMMUTABLE_CHECK_INITIALIZED_HARMONY, MISSING_BINDING }
enum	ConversionFlags {   NO_FLAGS = 0, ALLOW_HEX = 1, ALLOW_OCTAL = 2, ALLOW_IMPLICIT_OCTAL = 4,   ALLOW_BINARY = 8, ALLOW_TRAILING_JUNK = 16 }
enum	DtoaMode { DTOA_SHORTEST, DTOA_FIXED, DTOA_PRECISION }
enum	ElementsKind {   FAST_SMI_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_ELEMENTS,   FAST_DOUBLE_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, DICTIONARY_ELEMENTS, SLOPPY_ARGUMENTS_ELEMENTS,   EXTERNAL_INT8_ELEMENTS, EXTERNAL_UINT8_ELEMENTS, EXTERNAL_INT16_ELEMENTS, EXTERNAL_UINT16_ELEMENTS,   EXTERNAL_INT32_ELEMENTS, EXTERNAL_UINT32_ELEMENTS, EXTERNAL_FLOAT32_ELEMENTS, EXTERNAL_FLOAT64_ELEMENTS,   EXTERNAL_UINT8_CLAMPED_ELEMENTS, UINT8_ELEMENTS, INT8_ELEMENTS, UINT16_ELEMENTS,   INT16_ELEMENTS, UINT32_ELEMENTS, INT32_ELEMENTS, FLOAT32_ELEMENTS,   FLOAT64_ELEMENTS, UINT8_CLAMPED_ELEMENTS, FIRST_ELEMENTS_KIND = FAST_SMI_ELEMENTS, LAST_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,   FIRST_FAST_ELEMENTS_KIND = FAST_SMI_ELEMENTS, LAST_FAST_ELEMENTS_KIND = FAST_HOLEY_DOUBLE_ELEMENTS, FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND = EXTERNAL_INT8_ELEMENTS, LAST_EXTERNAL_ARRAY_ELEMENTS_KIND = EXTERNAL_UINT8_CLAMPED_ELEMENTS,   FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS, LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS, TERMINAL_FAST_ELEMENTS_KIND = FAST_HOLEY_ELEMENTS }
enum	InterruptFlag {   INTERRUPT = 1 << 0, DEBUGBREAK = 1 << 1, DEBUGCOMMAND = 1 << 2, PREEMPT = 1 << 3,   TERMINATE = 1 << 4, GC_REQUEST = 1 << 5, FULL_DEOPT = 1 << 6, INSTALL_CODE = 1 << 7,   API_INTERRUPT = 1 << 8, DEOPT_MARKED_ALLOCATION_SITES = 1 << 9 }
enum	FastDtoaMode { FAST_DTOA_SHORTEST, FAST_DTOA_PRECISION }
enum	ComputablePhase { DURING_PARSE, AFTER_SCOPING }
enum	PrologueFrameMode { BUILD_FUNCTION_FRAME, BUILD_STUB_FRAME }
enum	StrictMode { SLOPPY, STRICT }
enum	KeyCollectionType { LOCAL_ONLY, INCLUDE_PROTOS }
enum	LoggingAndProfiling { LOGGING_AND_PROFILING_ENABLED, LOGGING_AND_PROFILING_DISABLED }
enum	MarksHandling { TRANSFER_MARKS, IGNORE_MARKS }
enum	ArrayStorageAllocationMode { DONT_INITIALIZE_ARRAY_ELEMENTS, INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE }
enum	HAliasing { kMustAlias, kMayAlias, kNoAlias }
enum	PropertyAccessType { LOAD, STORE }
enum	GVNFlag { kNumberOfTrackedSideEffects = 0 GVN_TRACKED_FLAG_LIST(COUNT_FLAG), kNumberOfUntrackedSideEffects = 0 GVN_UNTRACKED_FLAG_LIST(COUNT_FLAG), kNumberOfFlags = kNumberOfTrackedSideEffects + kNumberOfUntrackedSideEffects }
enum	RemovableSimulate { REMOVABLE_SIMULATE, FIXED_SIMULATE }
enum	InliningKind { NORMAL_RETURN, CONSTRUCT_CALL_RETURN, GETTER_CALL_RETURN, SETTER_CALL_RETURN }
enum	LoadKeyedHoleMode { NEVER_RETURN_HOLE, ALLOW_RETURN_HOLE }
enum	StoreFieldOrKeyedMode { INITIALIZING_STORE, STORE_TO_INITIALIZED_ENTRY }
enum	FrameType {   JS_FUNCTION, JS_CONSTRUCT, JS_GETTER, JS_SETTER,   ARGUMENTS_ADAPTOR, STUB }
enum	ArgumentsAllowedFlag { ARGUMENTS_NOT_ALLOWED, ARGUMENTS_ALLOWED }
enum	Condition {   kNoCondition = -1, eq = 0 << 28, ne = 1 << 28, cs = 2 << 28,   cc = 3 << 28, mi = 4 << 28, pl = 5 << 28, vs = 6 << 28,   vc = 7 << 28, hi = 8 << 28, ls = 9 << 28, ge = 10 << 28,   lt = 11 << 28, gt = 12 << 28, le = 13 << 28, al = 14 << 28,   kSpecialCondition = 15 << 28, kNumberOfConditions = 16, hs = cs, lo = cc,   eq = 0 << 28, ne = 1 << 28, hs = cs, lo = cc,   mi = 4 << 28, pl = 5 << 28, vs = 6 << 28, vc = 7 << 28,   hi = 8 << 28, ls = 9 << 28, ge = 10 << 28, lt = 11 << 28,   gt = 12 << 28, le = 13 << 28, al = 14 << 28, nv = 15,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, carry = below, not_carry = above_equal, zero = equal,   not_zero = not_equal, sign = negative, not_sign = positive, kNoCondition = -1,   overflow = 0, no_overflow = 1, Uless = 2, Ugreater_equal = 3,   equal = 4, not_equal = 5, Uless_equal = 6, Ugreater = 7,   negative = 8, positive = 9, parity_even = 10, parity_odd = 11,   less = 12, greater_equal = 13, less_equal = 14, greater = 15,   ueq = 16, nue = 17, cc_always = 18, carry = below,   not_carry = above_equal, zero = equal, eq = 0 << 28, not_zero = not_equal,   ne = 1 << 28, nz = not_equal, sign = negative, not_sign = positive,   mi = 4 << 28, pl = 5 << 28, hi = 8 << 28, ls = 9 << 28,   ge = 10 << 28, lt = 11 << 28, gt = 12 << 28, le = 13 << 28,   hs = cs, lo = cc, al = 14 << 28, cc_default = kNoCondition,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, always = 16, never = 17, carry = below,   not_carry = above_equal, zero = equal, not_zero = not_equal, sign = negative,   not_sign = positive, last_condition = greater }
enum	ScaleFactor {   times_1 = 0, times_2 = 1, times_4 = 2, times_8 = 3,   times_int_size = times_4, times_half_pointer_size = times_2, times_pointer_size = times_4, times_twice_pointer_size = times_8,   times_1 = 0, times_2 = 1, times_4 = 2, times_8 = 3,   times_int_size = times_4, times_pointer_size = times_4 }
enum	RememberedSetAction {   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET }
enum	SmiCheck {   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK }
enum	RegisterValueType { REGISTER_VALUE_IS_SMI, REGISTER_VALUE_IS_INT32 }
enum	KeyedStoreCheckMap { kDontCheckMap, kCheckMap }
enum	KeyedStoreIncrementLength { kDontIncrementLength, kIncrementLength }
enum	OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT }
enum	InlinedSmiCheck { ENABLE_INLINED_SMI_CHECK, DISABLE_INLINED_SMI_CHECK }
enum	DefaultIsolateStatus { kDefaultIsolateUninitialized, kDefaultIsolateInitialized, kDefaultIsolateCrashIfInitialized }
enum	MayAccessDecision { YES, NO, UNKNOWN }
enum	ElementInSetsRelation { kInsideNone = 0, kInsideFirst = 1, kInsideSecond = 2, kInsideBoth = 3 }
enum	ContainedInLattice { kNotYet = 0, kLatticeIn = 1, kLatticeOut = 2, kLatticeUnknown = 3 }
enum	RegisterKind { UNALLOCATED_REGISTERS, GENERAL_REGISTERS, DOUBLE_REGISTERS }
enum	NumberUntagDMode { NUMBER_CANDIDATE_IS_SMI, NUMBER_CANDIDATE_IS_ANY_TAGGED }
enum	SweepingMode { SWEEP_ONLY, SWEEP_AND_VISIT_LIVE_OBJECTS }
enum	SkipListRebuildingMode { REBUILD_SKIP_LIST, IGNORE_SKIP_LIST }
enum	FreeSpaceTreatmentMode { IGNORE_FREE_SPACE, ZAP_FREE_SPACE }
enum	TypeofState {   INSIDE_TYPEOF, NOT_INSIDE_TYPEOF, INSIDE_TYPEOF, NOT_INSIDE_TYPEOF,   INSIDE_TYPEOF, NOT_INSIDE_TYPEOF }
enum	SoftwareInterruptCodes { kCallRtRedirected = 0x10, kBreakpoint = 0x20, kStopCode = 1 << 23, call_rt_redirected = 0xfffff }
enum	Opcode {   AND = 0 << 21, EOR = 1 << 21, SUB = 2 << 21, RSB = 3 << 21,   ADD = 4 << 21, ADC = 5 << 21, SBC = 6 << 21, RSC = 7 << 21,   TST = 8 << 21, TEQ = 9 << 21, CMP = 10 << 21, CMN = 11 << 21,   ORR = 12 << 21, MOV = 13 << 21, BIC = 14 << 21, MVN = 15 << 21,   SPECIAL = 0 << kOpcodeShift, REGIMM = 1 << kOpcodeShift, J = ((0 << 3) + 2) << kOpcodeShift, JAL = ((0 << 3) + 3) << kOpcodeShift,   BEQ = ((0 << 3) + 4) << kOpcodeShift, BNE = ((0 << 3) + 5) << kOpcodeShift, BLEZ = ((0 << 3) + 6) << kOpcodeShift, BGTZ = ((0 << 3) + 7) << kOpcodeShift,   ADDI = ((1 << 3) + 0) << kOpcodeShift, ADDIU = ((1 << 3) + 1) << kOpcodeShift, SLTI = ((1 << 3) + 2) << kOpcodeShift, SLTIU = ((1 << 3) + 3) << kOpcodeShift,   ANDI = ((1 << 3) + 4) << kOpcodeShift, ORI = ((1 << 3) + 5) << kOpcodeShift, XORI = ((1 << 3) + 6) << kOpcodeShift, LUI = ((1 << 3) + 7) << kOpcodeShift,   COP1 = ((2 << 3) + 1) << kOpcodeShift, BEQL = ((2 << 3) + 4) << kOpcodeShift, BNEL = ((2 << 3) + 5) << kOpcodeShift, BLEZL = ((2 << 3) + 6) << kOpcodeShift,   BGTZL = ((2 << 3) + 7) << kOpcodeShift, SPECIAL2 = ((3 << 3) + 4) << kOpcodeShift, SPECIAL3 = ((3 << 3) + 7) << kOpcodeShift, LB = ((4 << 3) + 0) << kOpcodeShift,   LH = ((4 << 3) + 1) << kOpcodeShift, LWL = ((4 << 3) + 2) << kOpcodeShift, LW = ((4 << 3) + 3) << kOpcodeShift, LBU = ((4 << 3) + 4) << kOpcodeShift,   LHU = ((4 << 3) + 5) << kOpcodeShift, LWR = ((4 << 3) + 6) << kOpcodeShift, SB = ((5 << 3) + 0) << kOpcodeShift, SH = ((5 << 3) + 1) << kOpcodeShift,   SWL = ((5 << 3) + 2) << kOpcodeShift, SW = ((5 << 3) + 3) << kOpcodeShift, SWR = ((5 << 3) + 6) << kOpcodeShift, LWC1 = ((6 << 3) + 1) << kOpcodeShift,   LDC1 = ((6 << 3) + 5) << kOpcodeShift, PREF = ((6 << 3) + 3) << kOpcodeShift, SWC1 = ((7 << 3) + 1) << kOpcodeShift, SDC1 = ((7 << 3) + 5) << kOpcodeShift,   COP1X = ((1 << 4) + 3) << kOpcodeShift }
enum	SecondaryField {   SLL = ((0 << 3) + 0), MOVCI = ((0 << 3) + 1), SRL = ((0 << 3) + 2), SRA = ((0 << 3) + 3),   SLLV = ((0 << 3) + 4), SRLV = ((0 << 3) + 6), SRAV = ((0 << 3) + 7), JR = ((1 << 3) + 0),   JALR = ((1 << 3) + 1), MOVZ = 0x40000000, MOVN = 0x00000000, BREAK = 1 << 0,   MFHI = ((2 << 3) + 0), MFLO = ((2 << 3) + 2), MULT = ((3 << 3) + 0), MULTU = ((3 << 3) + 1),   DIV = ((3 << 3) + 2), DIVU = ((3 << 3) + 3), ADD = 4 << 21, ADDU = ((4 << 3) + 1),   SUB = 2 << 21, SUBU = ((4 << 3) + 3), AND = 0 << 21, OR = ((4 << 3) + 5),   XOR = ((4 << 3) + 6), NOR = ((4 << 3) + 7), SLT = ((5 << 3) + 2), SLTU = ((5 << 3) + 3),   TGE = ((6 << 3) + 0), TGEU = ((6 << 3) + 1), TLT = ((6 << 3) + 2), TLTU = ((6 << 3) + 3),   TEQ = 9 << 21, TNE = ((6 << 3) + 6), MUL = ((0 << 3) + 2), CLZ = 1 << 4,   CLO = ((4 << 3) + 1), EXT = ((0 << 3) + 0), INS = ((0 << 3) + 4), BLTZ = ((0 << 3) + 0) << 16,   BGEZ = ((0 << 3) + 1) << 16, BLTZAL = ((2 << 3) + 0) << 16, BGEZAL = ((2 << 3) + 1) << 16, MFC1 = ((0 << 3) + 0) << 21,   CFC1 = ((0 << 3) + 2) << 21, MFHC1 = ((0 << 3) + 3) << 21, MTC1 = ((0 << 3) + 4) << 21, CTC1 = ((0 << 3) + 6) << 21,   MTHC1 = ((0 << 3) + 7) << 21, BC1 = ((1 << 3) + 0) << 21, S = 1 << 20, D = ((2 << 3) + 1) << 21,   W = 1 << 21, L = 1 << 20, PS = ((2 << 3) + 6) << 21, ROUND_L_S = ((1 << 3) + 0),   TRUNC_L_S = ((1 << 3) + 1), CEIL_L_S = ((1 << 3) + 2), FLOOR_L_S = ((1 << 3) + 3), ROUND_W_S = ((1 << 3) + 4),   TRUNC_W_S = ((1 << 3) + 5), CEIL_W_S = ((1 << 3) + 6), FLOOR_W_S = ((1 << 3) + 7), CVT_D_S = ((4 << 3) + 1),   CVT_W_S = ((4 << 3) + 4), CVT_L_S = ((4 << 3) + 5), CVT_PS_S = ((4 << 3) + 6), ADD_D = ((0 << 3) + 0),   SUB_D = ((0 << 3) + 1), MUL_D = ((0 << 3) + 2), DIV_D = ((0 << 3) + 3), SQRT_D = ((0 << 3) + 4),   ABS_D = ((0 << 3) + 5), MOV_D = ((0 << 3) + 6), NEG_D = ((0 << 3) + 7), ROUND_L_D = ((1 << 3) + 0),   TRUNC_L_D = ((1 << 3) + 1), CEIL_L_D = ((1 << 3) + 2), FLOOR_L_D = ((1 << 3) + 3), ROUND_W_D = ((1 << 3) + 4),   TRUNC_W_D = ((1 << 3) + 5), CEIL_W_D = ((1 << 3) + 6), FLOOR_W_D = ((1 << 3) + 7), CVT_S_D = ((4 << 3) + 0),   CVT_W_D = ((4 << 3) + 4), CVT_L_D = ((4 << 3) + 5), C_F_D = ((6 << 3) + 0), C_UN_D = ((6 << 3) + 1),   C_EQ_D = ((6 << 3) + 2), C_UEQ_D = ((6 << 3) + 3), C_OLT_D = ((6 << 3) + 4), C_ULT_D = ((6 << 3) + 5),   C_OLE_D = ((6 << 3) + 6), C_ULE_D = ((6 << 3) + 7), CVT_S_W = ((4 << 3) + 0), CVT_D_W = ((4 << 3) + 1),   CVT_S_L = ((4 << 3) + 0), CVT_D_L = ((4 << 3) + 1), MADD_D = ((4 << 3) + 1), NULLSF = 0 }
enum	Condition {   kNoCondition = -1, eq = 0 << 28, ne = 1 << 28, cs = 2 << 28,   cc = 3 << 28, mi = 4 << 28, pl = 5 << 28, vs = 6 << 28,   vc = 7 << 28, hi = 8 << 28, ls = 9 << 28, ge = 10 << 28,   lt = 11 << 28, gt = 12 << 28, le = 13 << 28, al = 14 << 28,   kSpecialCondition = 15 << 28, kNumberOfConditions = 16, hs = cs, lo = cc,   eq = 0 << 28, ne = 1 << 28, hs = cs, lo = cc,   mi = 4 << 28, pl = 5 << 28, vs = 6 << 28, vc = 7 << 28,   hi = 8 << 28, ls = 9 << 28, ge = 10 << 28, lt = 11 << 28,   gt = 12 << 28, le = 13 << 28, al = 14 << 28, nv = 15,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, carry = below, not_carry = above_equal, zero = equal,   not_zero = not_equal, sign = negative, not_sign = positive, kNoCondition = -1,   overflow = 0, no_overflow = 1, Uless = 2, Ugreater_equal = 3,   equal = 4, not_equal = 5, Uless_equal = 6, Ugreater = 7,   negative = 8, positive = 9, parity_even = 10, parity_odd = 11,   less = 12, greater_equal = 13, less_equal = 14, greater = 15,   ueq = 16, nue = 17, cc_always = 18, carry = below,   not_carry = above_equal, zero = equal, eq = 0 << 28, not_zero = not_equal,   ne = 1 << 28, nz = not_equal, sign = negative, not_sign = positive,   mi = 4 << 28, pl = 5 << 28, hi = 8 << 28, ls = 9 << 28,   ge = 10 << 28, lt = 11 << 28, gt = 12 << 28, le = 13 << 28,   hs = cs, lo = cc, al = 14 << 28, cc_default = kNoCondition,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, always = 16, never = 17, carry = below,   not_carry = above_equal, zero = equal, not_zero = not_equal, sign = negative,   not_sign = positive, last_condition = greater }
enum	FPUCondition {   kNoFPUCondition = -1, F = 0, UN = 1, EQ = 2,   UEQ = 3, OLT = 4, ULT = 5, OLE = 6,   ULE = 7 }
enum	FPURoundingMode {   RN = 0 << 22, RZ = 3 << 22, RP = 1 << 22, RM = 2 << 22,   kRoundToNearest = RN, kRoundToZero = RZ, kRoundToPlusInf = RP, kRoundToMinusInf = RM }
enum	CheckForInexactConversion { kCheckForInexactConversion, kDontCheckForInexactConversion, kCheckForInexactConversion, kDontCheckForInexactConversion }
enum	Hint { no_hint = 0, no_hint = 0 }
enum	LeaveExitFrameMode { EMIT_RETURN = true, NO_EMIT_RETURN = false }
enum	TaggingMode { TAG_RESULT, DONT_TAG_RESULT, TAG_RESULT, DONT_TAG_RESULT }
enum	ObjectToDoubleFlags { NO_OBJECT_TO_DOUBLE_FLAGS = 0, OBJECT_NOT_SMI = 1 << 0, AVOID_NANS_AND_INFINITIES = 1 << 1 }
enum	BranchDelaySlot { USE_DELAY_SLOT, PROTECT }
enum	LiFlags { OPTIMIZE_SIZE = 0, CONSTANT_SIZE = 1 }
enum	RememberedSetAction {   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET }
enum	SmiCheck {   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK }
enum	RAStatus { kRAHasNotBeenSaved, kRAHasBeenSaved }
enum	NativeType { CORE, EXPERIMENTAL, D8, TEST }
enum	KeyedAccessStoreMode {   STANDARD_STORE, STORE_TRANSITION_SMI_TO_OBJECT, STORE_TRANSITION_SMI_TO_DOUBLE, STORE_TRANSITION_DOUBLE_TO_OBJECT,   STORE_TRANSITION_HOLEY_SMI_TO_OBJECT, STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE, STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT, STORE_AND_GROW_NO_TRANSITION,   STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT, STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE, STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT, STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT,   STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE, STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT, STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, STORE_NO_TRANSITION_HANDLE_COW }
enum	ContextualMode { NOT_CONTEXTUAL, CONTEXTUAL }
enum	WriteBarrierMode { SKIP_WRITE_BARRIER, UPDATE_WRITE_BARRIER }
enum	StoreMode { ALLOW_AS_CONSTANT, FORCE_FIELD }
enum	PropertyNormalizationMode { CLEAR_INOBJECT_PROPERTIES, KEEP_INOBJECT_PROPERTIES }
enum	NormalizedMapSharingMode { UNIQUE_NORMALIZED_MAP, SHARED_NORMALIZED_MAP }
enum	TransitionFlag { INSERT_TRANSITION, OMIT_TRANSITION }
enum	DebugExtraICState { DEBUG_BREAK, DEBUG_PREPARE_STEP_IN }
enum	SimpleTransitionFlag { SIMPLE_TRANSITION, FULL_TRANSITION }
enum	DescriptorFlag { ALL_DESCRIPTORS, OWN_DESCRIPTORS }
enum	MarkingParity { NO_MARKING_PARITY, ODD_MARKING_PARITY, EVEN_MARKING_PARITY }
enum	StringRepresentationTag { kSeqStringTag = 0x0, kConsStringTag = 0x1, kExternalStringTag = 0x2, kSlicedStringTag = 0x3 }
enum	InstanceType {   INTERNALIZED_STRING_TYPE, ASCII_INTERNALIZED_STRING_TYPE, CONS_INTERNALIZED_STRING_TYPE, CONS_ASCII_INTERNALIZED_STRING_TYPE,   EXTERNAL_INTERNALIZED_STRING_TYPE, EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE, EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE,   SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE, SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, STRING_TYPE = INTERNALIZED_STRING_TYPE | kNotInternalizedTag, ASCII_STRING_TYPE = ASCII_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,   CONS_STRING_TYPE = CONS_INTERNALIZED_STRING_TYPE | kNotInternalizedTag, CONS_ASCII_STRING_TYPE, SLICED_STRING_TYPE, SLICED_ASCII_STRING_TYPE,   EXTERNAL_STRING_TYPE, EXTERNAL_ASCII_STRING_TYPE, EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, SHORT_EXTERNAL_STRING_TYPE,   SHORT_EXTERNAL_ASCII_STRING_TYPE, SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, SYMBOL_TYPE = kNotStringTag, MAP_TYPE,   CODE_TYPE, ODDBALL_TYPE, CELL_TYPE, PROPERTY_CELL_TYPE,   HEAP_NUMBER_TYPE, FOREIGN_TYPE, BYTE_ARRAY_TYPE, FREE_SPACE_TYPE,   EXTERNAL_INT8_ARRAY_TYPE, EXTERNAL_UINT8_ARRAY_TYPE, EXTERNAL_INT16_ARRAY_TYPE, EXTERNAL_UINT16_ARRAY_TYPE,   EXTERNAL_INT32_ARRAY_TYPE, EXTERNAL_UINT32_ARRAY_TYPE, EXTERNAL_FLOAT32_ARRAY_TYPE, EXTERNAL_FLOAT64_ARRAY_TYPE,   EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE, FIXED_INT8_ARRAY_TYPE, FIXED_UINT8_ARRAY_TYPE, FIXED_INT16_ARRAY_TYPE,   FIXED_UINT16_ARRAY_TYPE, FIXED_INT32_ARRAY_TYPE, FIXED_UINT32_ARRAY_TYPE, FIXED_FLOAT32_ARRAY_TYPE,   FIXED_FLOAT64_ARRAY_TYPE, FIXED_UINT8_CLAMPED_ARRAY_TYPE, FIXED_DOUBLE_ARRAY_TYPE, FILLER_TYPE,   DECLARED_ACCESSOR_DESCRIPTOR_TYPE, DECLARED_ACCESSOR_INFO_TYPE, EXECUTABLE_ACCESSOR_INFO_TYPE, ACCESSOR_PAIR_TYPE,   ACCESS_CHECK_INFO_TYPE, INTERCEPTOR_INFO_TYPE, CALL_HANDLER_INFO_TYPE, FUNCTION_TEMPLATE_INFO_TYPE,   OBJECT_TEMPLATE_INFO_TYPE, SIGNATURE_INFO_TYPE, TYPE_SWITCH_INFO_TYPE, ALLOCATION_SITE_TYPE,   ALLOCATION_MEMENTO_TYPE, SCRIPT_TYPE, CODE_CACHE_TYPE, POLYMORPHIC_CODE_CACHE_TYPE,   TYPE_FEEDBACK_INFO_TYPE, ALIASED_ARGUMENTS_ENTRY_TYPE, BOX_TYPE, DEBUG_INFO_TYPE,   BREAK_POINT_INFO_TYPE, FIXED_ARRAY_TYPE, CONSTANT_POOL_ARRAY_TYPE, SHARED_FUNCTION_INFO_TYPE,   JS_MESSAGE_OBJECT_TYPE, JS_FUNCTION_PROXY_TYPE, JS_PROXY_TYPE, JS_VALUE_TYPE,   JS_DATE_TYPE, JS_OBJECT_TYPE, JS_CONTEXT_EXTENSION_OBJECT_TYPE, JS_GENERATOR_OBJECT_TYPE,   JS_MODULE_TYPE, JS_GLOBAL_OBJECT_TYPE, JS_BUILTINS_OBJECT_TYPE, JS_GLOBAL_PROXY_TYPE,   JS_ARRAY_TYPE, JS_ARRAY_BUFFER_TYPE, JS_TYPED_ARRAY_TYPE, JS_DATA_VIEW_TYPE,   JS_SET_TYPE, JS_MAP_TYPE, JS_WEAK_MAP_TYPE, JS_WEAK_SET_TYPE,   JS_REGEXP_TYPE, JS_FUNCTION_TYPE, FIRST_TYPE = 0x0, LAST_TYPE = JS_FUNCTION_TYPE,   FIRST_NAME_TYPE = FIRST_TYPE, LAST_NAME_TYPE = SYMBOL_TYPE, FIRST_UNIQUE_NAME_TYPE = INTERNALIZED_STRING_TYPE, LAST_UNIQUE_NAME_TYPE = SYMBOL_TYPE,   FIRST_NONSTRING_TYPE = SYMBOL_TYPE, FIRST_EXTERNAL_ARRAY_TYPE = EXTERNAL_INT8_ARRAY_TYPE, LAST_EXTERNAL_ARRAY_TYPE = EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE, FIRST_FIXED_TYPED_ARRAY_TYPE = FIXED_INT8_ARRAY_TYPE,   LAST_FIXED_TYPED_ARRAY_TYPE = FIXED_UINT8_CLAMPED_ARRAY_TYPE, LAST_DATA_TYPE = FILLER_TYPE, FIRST_JS_RECEIVER_TYPE = JS_FUNCTION_PROXY_TYPE, LAST_JS_RECEIVER_TYPE = LAST_TYPE,   FIRST_JS_OBJECT_TYPE = JS_VALUE_TYPE, LAST_JS_OBJECT_TYPE = LAST_TYPE, FIRST_JS_PROXY_TYPE = JS_FUNCTION_PROXY_TYPE, LAST_JS_PROXY_TYPE = JS_PROXY_TYPE,   FIRST_SPEC_OBJECT_TYPE = FIRST_JS_RECEIVER_TYPE, LAST_SPEC_OBJECT_TYPE = LAST_JS_RECEIVER_TYPE, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_PROXY_TYPE, LAST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_REGEXP_TYPE,   NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2 }
enum	FixedArraySubInstanceType { LAST_FIXED_ARRAY_SUB_TYPE = TRANSITION_ARRAY_SUB_TYPE }
enum	CompareResult { LESS = -1, EQUAL = 0, GREATER = 1, NOT_EQUAL = GREATER }
enum	BailoutReason { kLastErrorMessage }
enum	EnsureElementsMode { DONT_ALLOW_DOUBLE_ELEMENTS, ALLOW_COPIED_DOUBLE_ELEMENTS, ALLOW_CONVERTED_DOUBLE_ELEMENTS }
enum	SetPropertyMode { SET_PROPERTY, DEFINE_PROPERTY }
enum	AccessorComponent { ACCESSOR_GETTER, ACCESSOR_SETTER }
enum	SearchMode { ALL_ENTRIES, VALID_ENTRIES }
enum	BuiltinFunctionId { kArrayCode, kMathPowHalf, kMathClz32 }
enum	AllocationSiteMode { DONT_TRACK_ALLOCATION_SITE, TRACK_ALLOCATION_SITE, LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE }
enum	AllowNullsFlag { ALLOW_NULLS, DISALLOW_NULLS }
enum	RobustnessFlag { ROBUST_STRING_TRAVERSAL, FAST_STRING_TRAVERSAL }
enum	AccessorDescriptorType {   kDescriptorBitmaskCompare, kDescriptorPointerCompare, kDescriptorPrimitiveValue, kDescriptorObjectDereference,   kDescriptorPointerDereference, kDescriptorPointerShift, kDescriptorReturnObject }
enum	{ ONCE_STATE_UNINITIALIZED = 0, ONCE_STATE_EXECUTING_FUNCTION = 1, ONCE_STATE_DONE = 2 }
enum	OutputMode { UNKNOWN, CONSOLE, ODS }
enum	PropertyType {   NORMAL = 0, FIELD = 1, CONSTANT = 2, CALLBACKS = 3,   HANDLER = 4, INTERCEPTOR = 5, TRANSITION = 6, NONEXISTENT = 7 }
enum	TypedArraySetResultCodes { TYPED_ARRAY_SET_TYPED_ARRAY_SAME_TYPE = 0, TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING = 1, TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING = 2, TYPED_ARRAY_SET_NON_TYPED_ARRAY = 3 }
enum	AccessCheckResult { ACCESS_FORBIDDEN, ACCESS_ALLOWED, ACCESS_ABSENT }
enum	PropertyDescriptorIndices {   IS_ACCESSOR_INDEX, VALUE_INDEX, GETTER_INDEX, SETTER_INDEX,   WRITABLE_INDEX, ENUMERABLE_INDEX, CONFIGURABLE_INDEX, DESCRIPTOR_SIZE }
enum	TypeCode {   UNCLASSIFIED, BUILTIN, RUNTIME_FUNCTION, IC_UTILITY,   DEBUG_ADDRESS, STATS_COUNTER, TOP_ADDRESS, C_BUILTIN,   EXTENSION, ACCESSOR, RUNTIME_ENTRY, STUB_CACHE_TABLE,   LAZY_DEOPTIMIZATION }
enum	SemiSpaceId { kFromSpace = 0, kToSpace = 1 }
enum	PrototypeCheckType { CHECK_ALL_MAPS, SKIP_RECEIVER }
enum	IcCheckType { ELEMENT, PROPERTY }
enum	FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS }
enum	NilValue { kNullValue, kUndefinedValue }
enum	AllocationSpace {   NEW_SPACE, OLD_POINTER_SPACE, OLD_DATA_SPACE, CODE_SPACE,   MAP_SPACE, CELL_SPACE, PROPERTY_CELL_SPACE, LO_SPACE,   FIRST_SPACE = NEW_SPACE, LAST_SPACE = LO_SPACE, FIRST_PAGED_SPACE = OLD_POINTER_SPACE, LAST_PAGED_SPACE = PROPERTY_CELL_SPACE }
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 }
enum	NativesFlag { NOT_NATIVES_CODE, NATIVES_CODE }
enum	InlineCacheState {   UNINITIALIZED, PREMONOMORPHIC, MONOMORPHIC, MONOMORPHIC_PROTOTYPE_FAILURE,   POLYMORPHIC, MEGAMORPHIC, GENERIC, DEBUG_STUB }
enum	CallFunctionFlags { NO_CALL_FUNCTION_FLAGS, RECORD_CALL_TARGET, CALL_AS_METHOD, WRAP_AND_CALL }
enum	InlineCacheHolderFlag { OWN_MAP, PROTOTYPE_MAP }
enum	StoreBufferEvent { kStoreBufferFullEvent, kStoreBufferStartScanningPagesEvent, kStoreBufferScanningPageEvent }
enum	StateTag {   JS, GC, COMPILER, OTHER,   EXTERNAL, IDLE }
enum	CpuFeature {   SSE4_1 = 32 + 19, SSE3 = 32 + 0, SSE2 = 26, CMOV = 15,   VFP3 = 1, ARMv7 = 2, SUDIV = 3, UNALIGNED_ACCESSES = 4,   MOVW_MOVT_IMMEDIATE_LOADS = 5, VFP32DREGS = 6, NEON = 7, SAHF = 0,   FPU = 1 }
enum	SmiCheckType { DONT_DO_SMI_CHECK, DO_SMI_CHECK }
enum	ScopeType {   EVAL_SCOPE, FUNCTION_SCOPE, MODULE_SCOPE, GLOBAL_SCOPE,   CATCH_SCOPE, BLOCK_SCOPE, WITH_SCOPE }
enum	VariableMode {   VAR, CONST_LEGACY, LET, CONST,   MODULE, INTERNAL, TEMPORARY, DYNAMIC,   DYNAMIC_GLOBAL, DYNAMIC_LOCAL }
enum	InitializationFlag { kNeedsInitialization, kCreatedInitialized }
enum	ClearExceptionFlag { KEEP_EXCEPTION, CLEAR_EXCEPTION }
enum	MinusZeroMode { TREAT_MINUS_ZERO_AS_ZERO, FAIL_ON_MINUS_ZERO }
enum	Condition {   kNoCondition = -1, eq = 0 << 28, ne = 1 << 28, cs = 2 << 28,   cc = 3 << 28, mi = 4 << 28, pl = 5 << 28, vs = 6 << 28,   vc = 7 << 28, hi = 8 << 28, ls = 9 << 28, ge = 10 << 28,   lt = 11 << 28, gt = 12 << 28, le = 13 << 28, al = 14 << 28,   kSpecialCondition = 15 << 28, kNumberOfConditions = 16, hs = cs, lo = cc,   eq = 0 << 28, ne = 1 << 28, hs = cs, lo = cc,   mi = 4 << 28, pl = 5 << 28, vs = 6 << 28, vc = 7 << 28,   hi = 8 << 28, ls = 9 << 28, ge = 10 << 28, lt = 11 << 28,   gt = 12 << 28, le = 13 << 28, al = 14 << 28, nv = 15,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, carry = below, not_carry = above_equal, zero = equal,   not_zero = not_equal, sign = negative, not_sign = positive, kNoCondition = -1,   overflow = 0, no_overflow = 1, Uless = 2, Ugreater_equal = 3,   equal = 4, not_equal = 5, Uless_equal = 6, Ugreater = 7,   negative = 8, positive = 9, parity_even = 10, parity_odd = 11,   less = 12, greater_equal = 13, less_equal = 14, greater = 15,   ueq = 16, nue = 17, cc_always = 18, carry = below,   not_carry = above_equal, zero = equal, eq = 0 << 28, not_zero = not_equal,   ne = 1 << 28, nz = not_equal, sign = negative, not_sign = positive,   mi = 4 << 28, pl = 5 << 28, hi = 8 << 28, ls = 9 << 28,   ge = 10 << 28, lt = 11 << 28, gt = 12 << 28, le = 13 << 28,   hs = cs, lo = cc, al = 14 << 28, cc_default = kNoCondition,   no_condition = -1, overflow = 0, no_overflow = 1, below = 2,   above_equal = 3, equal = 4, not_equal = 5, below_equal = 6,   above = 7, negative = 8, positive = 9, parity_even = 10,   parity_odd = 11, less = 12, greater_equal = 13, less_equal = 14,   greater = 15, always = 16, never = 17, carry = below,   not_carry = above_equal, zero = equal, not_zero = not_equal, sign = negative,   not_sign = positive, last_condition = greater }
enum	ScaleFactor {   times_1 = 0, times_2 = 1, times_4 = 2, times_8 = 3,   times_int_size = times_4, times_half_pointer_size = times_2, times_pointer_size = times_4, times_twice_pointer_size = times_8,   times_1 = 0, times_2 = 1, times_4 = 2, times_8 = 3,   times_int_size = times_4, times_pointer_size = times_4 }
enum	TypeofState {   INSIDE_TYPEOF, NOT_INSIDE_TYPEOF, INSIDE_TYPEOF, NOT_INSIDE_TYPEOF,   INSIDE_TYPEOF, NOT_INSIDE_TYPEOF }
enum	StackArgumentsAccessorReceiverMode { ARGUMENTS_CONTAIN_RECEIVER, ARGUMENTS_DONT_CONTAIN_RECEIVER }
enum	RememberedSetAction {   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET,   EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET }
enum	SmiCheck {   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK, INLINE_SMI_CHECK, OMIT_SMI_CHECK,   INLINE_SMI_CHECK, OMIT_SMI_CHECK }
enum	SmiOperationConstraint { PRESERVE_SOURCE_REGISTER, BAILOUT_ON_NO_OVERFLOW, BAILOUT_ON_OVERFLOW, NUMBER_OF_CONSTRAINTS }

Functions
template<int kSmiShiftSize>
V8_INLINE internal::Object *	IntToSmi (int value)
char *	StrDup (const char *str)
char *	StrNDup (const char *str, int n)
void *	AlignedAlloc (size_t size, size_t alignment)
void	AlignedFree (void *ptr)
void	FatalProcessOutOfMemory (const char *message)
template<typename T >
T *	NewArray (size_t size)
template<typename T >
void	DeleteArray (T *array)
void	InvokeAccessorGetterCallback (v8::Local< v8::String > property, const v8::PropertyCallbackInfo< v8::Value > &info, v8::AccessorGetterCallback getter)
void	InvokeFunctionCallback (const v8::FunctionCallbackInfo< v8::Value > &info, v8::FunctionCallback callback)
double	ClobberDoubleRegisters (double x1, double x2, double x3, double x4)
void	ArrayNativeCode (MacroAssembler *masm, Label *call_generic_code)
int	EncodeConstantPoolLength (int length)
int	DecodeConstantPoolLength (int instr)
Condition	NegateCondition (Condition cond)
Condition	ReverseCondition (Condition cond)
Hint	NegateHint (Hint ignored)
int	JSCallerSavedCode (int n)
MemOperand	FieldMemOperand (Register object, int offset)
Register	GetRegisterThatIsNotOneOf (Register reg1, Register reg2=no_reg, Register reg3=no_reg, Register reg4=no_reg, Register reg5=no_reg, Register reg6=no_reg)
MemOperand	ContextOperand (Register context, int index)
MemOperand	GlobalObjectOperand ()
	STATIC_ASSERT (sizeof(CPURegister)==sizeof(Register))
	INITIALIZE_REGISTER (Register, NoReg, 0, 0, CPURegister::kNoRegister)
	INITIALIZE_REGISTER (FPRegister, NoFPReg, 0, 0, CPURegister::kNoRegister)
	INITIALIZE_REGISTER (CPURegister, NoCPUReg, 0, 0, CPURegister::kNoRegister)
	INITIALIZE_REGISTER (Register, no_reg, 0, 0, CPURegister::kNoRegister)
	INITIALIZE_REGISTER (Register, wcsp, kSPRegInternalCode, kWRegSizeInBits, CPURegister::kRegister)
	INITIALIZE_REGISTER (Register, csp, kSPRegInternalCode, kXRegSizeInBits, CPURegister::kRegister)
	ALIAS_REGISTER (Register, ip0, x16)
	ALIAS_REGISTER (Register, ip1, x17)
	ALIAS_REGISTER (Register, wip0, w16)
	ALIAS_REGISTER (Register, wip1, w17)
	ALIAS_REGISTER (Register, root, x26)
	ALIAS_REGISTER (Register, rr, x26)
	ALIAS_REGISTER (Register, cp, x27)
	STATIC_ASSERT (kJSSPCode==28)
	ALIAS_REGISTER (Register, jssp, x28)
	ALIAS_REGISTER (Register, wjssp, w28)
	ALIAS_REGISTER (Register, fp, x29)
	ALIAS_REGISTER (Register, lr, x30)
	ALIAS_REGISTER (Register, xzr, x31)
	ALIAS_REGISTER (Register, wzr, w31)
	ALIAS_REGISTER (FPRegister, fp_zero, d15)
	ALIAS_REGISTER (FPRegister, crankshaft_fp_scratch, d30)
	ALIAS_REGISTER (FPRegister, fp_scratch, d31)
Register	GetAllocatableRegisterThatIsNotOneOf (Register reg1, Register reg2=NoReg, Register reg3=NoReg, Register reg4=NoReg)
bool	AreAliased (const CPURegister &reg1, const CPURegister &reg2, const CPURegister &reg3=NoReg, const CPURegister &reg4=NoReg, const CPURegister &reg5=NoReg, const CPURegister &reg6=NoReg, const CPURegister &reg7=NoReg, const CPURegister &reg8=NoReg)
bool	AreSameSizeAndType (const CPURegister &reg1, const CPURegister &reg2, const CPURegister &reg3=NoCPUReg, const CPURegister &reg4=NoCPUReg, const CPURegister &reg5=NoCPUReg, const CPURegister &reg6=NoCPUReg, const CPURegister &reg7=NoCPUReg, const CPURegister &reg8=NoCPUReg)
Condition	InvertCondition (Condition cond)
Condition	ReverseConditionForCmp (Condition cond)
	DEFINE_FLOAT (kFP32PositiveInfinity, 0x7f800000)
	DEFINE_FLOAT (kFP32NegativeInfinity, 0xff800000)
	DEFINE_DOUBLE (kFP64PositiveInfinity, 0x7ff0000000000000UL)
	DEFINE_DOUBLE (kFP64NegativeInfinity, 0xfff0000000000000UL)
	DEFINE_DOUBLE (kFP64SignallingNaN, 0x7ff000007f800001)
	DEFINE_FLOAT (kFP32SignallingNaN, 0x7f800001)
	DEFINE_DOUBLE (kFP64QuietNaN, 0x7ff800007fc00001)
	DEFINE_FLOAT (kFP32QuietNaN, 0x7fc00001)
	DEFINE_DOUBLE (kFP64DefaultNaN, 0x7ff8000000000000UL)
	DEFINE_FLOAT (kFP32DefaultNaN, 0x7fc00000)
LSDataSize	CalcLSPairDataSize (LoadStorePairOp op)
MemOperand	UntagSmiFieldMemOperand (Register object, int offset)
MemOperand	UntagSmiMemOperand (Register object, int offset)
BranchType	InvertBranchType (BranchType type)
MemOperand	ContextMemOperand (Register context, int index)
MemOperand	GlobalObjectMemOperand ()
	STATIC_ASSERT ((static_cast< int32_t >(-1) >> 1)==-1)
	STATIC_ASSERT ((static_cast< uint32_t >(-1) >> 1)==0x7FFFFFFF)
int	CountLeadingZeros (uint64_t value, int width)
int	CountLeadingSignBits (int64_t value, int width)
int	CountTrailingZeros (uint64_t value, int width)
int	CountSetBits (uint64_t value, int width)
int	MaskToBit (uint64_t mask)
bool	IsSignallingNaN (double num)
bool	IsSignallingNaN (float num)
template<typename T >
bool	IsQuietNaN (T num)
double	ToQuietNaN (double num)
float	ToQuietNaN (float num)
double	FusedMultiplyAdd (double op1, double op2, double a)
float	FusedMultiplyAdd (float op1, float op2, float a)
double	power_helper (double x, double y)
double	power_double_int (double x, int y)
double	power_double_double (double x, double y)
bool	EvalComparison (Token::Value op, double op1, double op2)
int	NumberOfBitsSet (uint32_t x)
Atomic32	NoBarrier_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)
Atomic32	NoBarrier_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)
Atomic32	NoBarrier_AtomicIncrement (volatile Atomic32 *ptr, Atomic32 increment)
Atomic32	Barrier_AtomicIncrement (volatile Atomic32 *ptr, Atomic32 increment)
Atomic32	Acquire_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)
Atomic32	Release_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)
void	MemoryBarrier ()
void	NoBarrier_Store (volatile Atomic32 *ptr, Atomic32 value)
void	Acquire_Store (volatile Atomic32 *ptr, Atomic32 value)
void	Release_Store (volatile Atomic32 *ptr, Atomic32 value)
Atomic32	NoBarrier_Load (volatile const Atomic32 *ptr)
Atomic32	Acquire_Load (volatile const Atomic32 *ptr)
Atomic32	Release_Load (volatile const Atomic32 *ptr)
Atomic64	NoBarrier_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)
Atomic64	NoBarrier_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)
Atomic64	NoBarrier_AtomicIncrement (volatile Atomic64 *ptr, Atomic64 increment)
Atomic64	Barrier_AtomicIncrement (volatile Atomic64 *ptr, Atomic64 increment)
Atomic64	Acquire_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)
Atomic64	Release_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)
void	NoBarrier_Store (volatile Atomic64 *ptr, Atomic64 value)
void	Acquire_Store (volatile Atomic64 *ptr, Atomic64 value)
void	Release_Store (volatile Atomic64 *ptr, Atomic64 value)
Atomic64	NoBarrier_Load (volatile const Atomic64 *ptr)
Atomic64	Acquire_Load (volatile const Atomic64 *ptr)
Atomic64	Release_Load (volatile const Atomic64 *ptr)
AtomicWord	NoBarrier_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)
AtomicWord	NoBarrier_AtomicExchange (volatile AtomicWord *ptr, AtomicWord new_value)
AtomicWord	NoBarrier_AtomicIncrement (volatile AtomicWord *ptr, AtomicWord increment)
AtomicWord	Barrier_AtomicIncrement (volatile AtomicWord *ptr, AtomicWord increment)
AtomicWord	Acquire_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)
AtomicWord	Release_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)
void	NoBarrier_Store (volatile AtomicWord *ptr, AtomicWord value)
void	Acquire_Store (volatile AtomicWord *ptr, AtomicWord value)
void	Release_Store (volatile AtomicWord *ptr, AtomicWord value)
AtomicWord	NoBarrier_Load (volatile const AtomicWord *ptr)
AtomicWord	Acquire_Load (volatile const AtomicWord *ptr)
AtomicWord	Release_Load (volatile const AtomicWord *ptr)
__tsan_atomic8	__tsan_atomic8_load (const volatile __tsan_atomic8 *a, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_load (const volatile __tsan_atomic16 *a, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_load (const volatile __tsan_atomic32 *a, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_load (const volatile __tsan_atomic64 *a, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_load (const volatile __tsan_atomic128 *a, __tsan_memory_order mo)
void	__tsan_atomic8_store (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
void	__tsan_atomic16_store (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
void	__tsan_atomic32_store (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
void	__tsan_atomic64_store (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
void	__tsan_atomic128_store (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_exchange (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_exchange (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_exchange (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_exchange (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_exchange (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_add (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_add (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_add (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_add (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_add (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_and (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_and (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_and (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_and (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_and (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_or (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_or (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_or (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_or (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_or (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_xor (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_xor (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_xor (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_xor (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_xor (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_nand (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_nand (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_nand (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_nand (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_nand (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
int	__tsan_atomic8_compare_exchange_weak (volatile __tsan_atomic8 *a, __tsan_atomic8 *c, __tsan_atomic8 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic16_compare_exchange_weak (volatile __tsan_atomic16 *a, __tsan_atomic16 *c, __tsan_atomic16 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic32_compare_exchange_weak (volatile __tsan_atomic32 *a, __tsan_atomic32 *c, __tsan_atomic32 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic64_compare_exchange_weak (volatile __tsan_atomic64 *a, __tsan_atomic64 *c, __tsan_atomic64 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic128_compare_exchange_weak (volatile __tsan_atomic128 *a, __tsan_atomic128 *c, __tsan_atomic128 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic8_compare_exchange_strong (volatile __tsan_atomic8 *a, __tsan_atomic8 *c, __tsan_atomic8 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic16_compare_exchange_strong (volatile __tsan_atomic16 *a, __tsan_atomic16 *c, __tsan_atomic16 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic32_compare_exchange_strong (volatile __tsan_atomic32 *a, __tsan_atomic32 *c, __tsan_atomic32 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic64_compare_exchange_strong (volatile __tsan_atomic64 *a, __tsan_atomic64 *c, __tsan_atomic64 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic128_compare_exchange_strong (volatile __tsan_atomic128 *a, __tsan_atomic128 *c, __tsan_atomic128 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic8	__tsan_atomic8_compare_exchange_val (volatile __tsan_atomic8 *a, __tsan_atomic8 c, __tsan_atomic8 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic16	__tsan_atomic16_compare_exchange_val (volatile __tsan_atomic16 *a, __tsan_atomic16 c, __tsan_atomic16 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic32	__tsan_atomic32_compare_exchange_val (volatile __tsan_atomic32 *a, __tsan_atomic32 c, __tsan_atomic32 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic64	__tsan_atomic64_compare_exchange_val (volatile __tsan_atomic64 *a, __tsan_atomic64 c, __tsan_atomic64 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic128	__tsan_atomic128_compare_exchange_val (volatile __tsan_atomic128 *a, __tsan_atomic128 c, __tsan_atomic128 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
void	__tsan_atomic_thread_fence (__tsan_memory_order mo)
void	__tsan_atomic_signal_fence (__tsan_memory_order mo)
Atomic32	Acquire_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)
Atomic32	Release_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)
Atomic64	Acquire_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)
Atomic64	Release_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)
void	BignumDtoa (double v, BignumDtoaMode mode, int requested_digits, Vector< char > buffer, int *length, int *decimal_point)
	BUILTIN (Illegal)
	BUILTIN (EmptyFunction)
	BUILTIN (ArrayPush)
	BUILTIN (ArrayPop)
	BUILTIN (ArrayShift)
	BUILTIN (ArrayUnshift)
	BUILTIN (ArraySlice)
	BUILTIN (ArraySplice)
	BUILTIN (ArrayConcat)
	BUILTIN (StrictModePoisonPill)
	BUILTIN (HandleApiCall)
	BUILTIN (HandleApiCallConstruct)
	BUILTIN (HandleApiCallAsFunction)
	BUILTIN (HandleApiCallAsConstructor)
int	AsciiAlphaToLower (uc32 c)
bool	IsCarriageReturn (uc32 c)
bool	IsLineFeed (uc32 c)
bool	IsInRange (int value, int lower_limit, int higher_limit)
bool	IsDecimalDigit (uc32 c)
bool	IsHexDigit (uc32 c)
bool	IsOctalDigit (uc32 c)
bool	IsBinaryDigit (uc32 c)
bool	IsRegExpWord (uc16 c)
bool	IsRegExpNewline (uc16 c)
bool	IsRegExpWord (uc32 c)
bool	IsRegExpNewline (uc32 c)
intptr_t	HeapObjectTagMask ()
void	DumpBacktrace ()
UnaryMathFunction	CreateExpFunction ()
UnaryMathFunction	CreateSqrtFunction ()
void	SetExpectedNofPropertiesFromEstimate (Handle< SharedFunctionInfo > shared, int estimate)
double	JunkStringValue ()
double	SignedZero (bool negative)
unsigned int	FastD2UI (double x)
double	DoubleToInteger (double x)
int32_t	DoubleToInt32 (double x)
template<class Iterator , class EndMark >
bool	SubStringEquals (Iterator *current, EndMark end, const char *substring)
template<class Iterator , class EndMark >
bool	AdvanceToNonspace (UnicodeCache *unicode_cache, Iterator *current, EndMark end)
template<int radix_log_2, class Iterator , class EndMark >
double	InternalStringToIntDouble (UnicodeCache *unicode_cache, Iterator current, EndMark end, bool negative, bool allow_trailing_junk)
template<class Iterator , class EndMark >
double	InternalStringToInt (UnicodeCache *unicode_cache, Iterator current, EndMark end, int radix)
template<class Iterator , class EndMark >
double	InternalStringToDouble (UnicodeCache *unicode_cache, Iterator current, EndMark end, int flags, double empty_string_val)
double	StringToDouble (UnicodeCache *unicode_cache, const char *str, int flags, double empty_string_val)
double	StringToDouble (UnicodeCache *unicode_cache, Vector< const char > str, int flags, double empty_string_val)
double	StringToDouble (UnicodeCache *unicode_cache, Vector< const uc16 > str, int flags, double empty_string_val)
const char *	DoubleToCString (double v, Vector< char > buffer)
const char *	IntToCString (int n, Vector< char > buffer)
char *	DoubleToFixedCString (double value, int f)
char *	DoubleToExponentialCString (double value, int f)
char *	DoubleToPrecisionCString (double value, int p)
char *	DoubleToRadixCString (double value, int radix)
bool	isDigit (int x, int radix)
bool	isBinaryDigit (int x)
int	FastD2IChecked (double x)
int	FastD2I (double x)
double	FastI2D (int x)
double	FastUI2D (unsigned x)
uint32_t	DoubleToUint32 (double x)
uint64_t	double_to_uint64 (double d)
double	uint64_to_double (uint64_t d64)
void	DoubleToAscii (double v, DtoaMode mode, int requested_digits, Vector< char > buffer, int *sign, int *length, int *point)
int	ElementsKindToShiftSize (ElementsKind elements_kind)
const char *	ElementsKindToString (ElementsKind kind)
void	PrintElementsKind (FILE *out, ElementsKind kind)
ElementsKind	GetInitialFastElementsKind ()
ElementsKind	GetFastElementsKindFromSequenceIndex (int sequence_number)
int	GetSequenceIndexFromFastElementsKind (ElementsKind elements_kind)
ElementsKind	GetNextTransitionElementsKind (ElementsKind kind)
ElementsKind	GetNextMoreGeneralFastElementsKind (ElementsKind elements_kind, bool allow_only_packed)
bool	IsMoreGeneralElementsKindTransition (ElementsKind from_kind, ElementsKind to_kind)
bool	IsDictionaryElementsKind (ElementsKind kind)
bool	IsExternalArrayElementsKind (ElementsKind kind)
bool	IsTerminalElementsKind (ElementsKind kind)
bool	IsFixedTypedArrayElementsKind (ElementsKind kind)
bool	IsFastElementsKind (ElementsKind kind)
bool	IsTransitionElementsKind (ElementsKind kind)
bool	IsFastDoubleElementsKind (ElementsKind kind)
bool	IsExternalFloatOrDoubleElementsKind (ElementsKind kind)
bool	IsFixedFloatElementsKind (ElementsKind kind)
bool	IsDoubleOrFloatElementsKind (ElementsKind kind)
bool	IsFastSmiOrObjectElementsKind (ElementsKind kind)
bool	IsFastSmiElementsKind (ElementsKind kind)
bool	IsFastObjectElementsKind (ElementsKind kind)
bool	IsFastHoleyElementsKind (ElementsKind kind)
bool	IsHoleyElementsKind (ElementsKind kind)
bool	IsFastPackedElementsKind (ElementsKind kind)
ElementsKind	GetPackedElementsKind (ElementsKind holey_kind)
ElementsKind	GetHoleyElementsKind (ElementsKind packed_kind)
ElementsKind	FastSmiToObjectElementsKind (ElementsKind from_kind)
bool	IsSimpleMapChangeTransition (ElementsKind from_kind, ElementsKind to_kind)
bool	IsTransitionableFastElementsKind (ElementsKind from_kind)
bool	CanTransitionToMoreGeneralFastElementsKind (ElementsKind elements_kind, bool allow_only_packed)
void	CheckArrayAbuse (JSObject *obj, const char *op, uint32_t key, bool allow_appending)
Handle< Object >	ArrayConstructInitializeElements (Handle< JSArray > array, Arguments *args)
template<typename SinkChar , typename StringType >
Handle< String >	ConcatStringContent (Handle< StringType > result, Handle< String > first, Handle< String > second)
bool	FastDtoa (double v, FastDtoaMode mode, int requested_digits, Vector< char > buffer, int *length, int *decimal_point)
bool	FastFixedDtoa (double v, int fractional_count, Vector< char > buffer, int *length, int *decimal_point)
	DEFINE_bool (use_strict, false,"enforce strict mode") DEFINE_bool(es_staging
enable upcoming ES6 features	DEFINE_bool (harmony_typeof, false,"enable harmony semantics for typeof") DEFINE_bool(harmony_scoping
enable upcoming ES6 features enable harmony block scoping	DEFINE_bool (harmony_modules, false,"enable harmony modules (implies block scoping)") DEFINE_bool(harmony_symbols
enable upcoming ES6 features enable harmony block scoping enable harmony	symbols (a.k.a.private names)") DEFINE_bool(harmony_proxies
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies	DEFINE_bool (harmony_collections, false,"enable harmony collections (sets, maps)") DEFINE_bool(harmony_generators
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators	DEFINE_bool (harmony_iteration, false,"enable harmony iteration (for-of)") DEFINE_bool(harmony_numeric_literals
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric	literals (0o77, 0b11)") DEFINE_bool(harmony_strings
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string	DEFINE_bool (harmony_arrays, false,"enable harmony arrays") DEFINE_bool(harmony_maths
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions	DEFINE_bool (harmony, false,"enable all harmony features (except typeof)") DEFINE_implication(harmony
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping	DEFINE_implication (harmony, harmony_modules) DEFINE_implication(harmony
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols	DEFINE_implication (harmony, harmony_proxies) DEFINE_implication(harmony
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections	DEFINE_implication (harmony, harmony_generators) DEFINE_implication(harmony
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration	DEFINE_implication (harmony, harmony_numeric_literals) DEFINE_implication(harmony
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings	DEFINE_implication (harmony, harmony_arrays) DEFINE_implication(harmony_modules
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping	DEFINE_implication (harmony, es_staging) DEFINE_implication(es_staging
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths	DEFINE_bool (packed_arrays, true,"optimizes arrays that have no holes") DEFINE_bool(smi_only_arrays
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values	DEFINE_bool (compiled_keyed_dictionary_loads, true,"use optimizing compiler to generate keyed dictionary load stubs") DEFINE_bool(clever_optimizations
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string	DEFINE_bool (pretenuring, true,"allocate objects in old space") DEFINE_bool(pretenuring_call_new
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new	DEFINE_bool (allocation_site_pretenuring, true,"pretenure with allocation sites") DEFINE_bool(trace_pretenuring
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions	DEFINE_bool (trace_pretenuring_statistics, false,"trace allocation site pretenuring statistics") DEFINE_bool(track_fields
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values	DEFINE_bool (track_double_fields, true,"track fields with double values") DEFINE_bool(track_heap_object_fields
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values	DEFINE_bool (track_computed_fields, true,"track computed boilerplate fields") DEFINE_implication(track_double_fields
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields	DEFINE_implication (track_heap_object_fields, track_fields) DEFINE_implication(track_computed_fields
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields	DEFINE_bool (smi_binop, true,"support smi representation in binary operations") DEFINE_bool(optimize_for_size
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed	DEFINE_bool (unbox_double_arrays, true,"automatically unbox arrays of doubles") DEFINE_bool(string_slices
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices	DEFINE_bool (crankshaft, true,"use crankshaft") DEFINE_string(hydrogen_filter
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter	DEFINE_bool (use_gvn, true,"use hydrogen global value numbering") DEFINE_int(gvn_iterations
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations	DEFINE_bool (use_canonicalizing, true,"use hydrogen instruction canonicalizing") DEFINE_bool(use_inlining
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining	DEFINE_bool (use_escape_analysis, true,"use hydrogen escape analysis") DEFINE_bool(use_allocation_folding
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding	DEFINE_bool (use_local_allocation_folding, false,"only fold in basic blocks") DEFINE_bool(use_write_barrier_elimination
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code	DEFINE_int (max_inlining_levels, 5,"maximum number of inlining levels") DEFINE_int(max_inlined_source_size
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining	DEFINE_int (max_inlined_nodes, 196,"maximum number of AST nodes considered for a single inlining") DEFINE_int(max_inlined_nodes_cumulative
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining	DEFINE_bool (loop_invariant_code_motion, true,"loop invariant code motion") DEFINE_bool(fast_math
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining	faster (but maybe less accurate) math functions") DEFINE_bool(collect_megamorphic_maps_from_stub_cache
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache	DEFINE_bool (hydrogen_stats, false,"print statistics for hydrogen") DEFINE_bool(trace_check_elimination
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase	DEFINE_bool (trace_hydrogen, false,"trace generated hydrogen to file") DEFINE_string(trace_hydrogen_filter
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter	DEFINE_bool (trace_hydrogen_stubs, false,"trace generated hydrogen for stubs") DEFINE_string(trace_hydrogen_file
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name	DEFINE_string (trace_phase,"HLZ","trace generated IR for specified phases") DEFINE_bool(trace_inlining
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions	DEFINE_bool (trace_load_elimination, false,"trace load elimination") DEFINE_bool(trace_store_elimination
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination	DEFINE_bool (trace_alloc, false,"trace register allocator") DEFINE_bool(trace_all_uses
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions	DEFINE_bool (trace_range, false,"trace range analysis") DEFINE_bool(trace_gvn
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering	DEFINE_bool (trace_representation, false,"trace representation types") DEFINE_bool(trace_escape_analysis
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis	DEFINE_bool (trace_allocation_folding, false,"trace allocation folding") DEFINE_bool(trace_track_allocation_sites
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites	DEFINE_bool (trace_migration, false,"trace object migration") DEFINE_bool(trace_generalization
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization	DEFINE_bool (stress_pointer_maps, false,"pointer map for every instruction") DEFINE_bool(stress_environments
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction	DEFINE_int (deopt_every_n_times, 0,"deoptimize every n times a deopt point is passed") DEFINE_int(deopt_every_n_garbage_collections
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections	DEFINE_bool (print_deopt_stress, false,"print number of possible deopt points") DEFINE_bool(trap_on_deopt
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing	DEFINE_bool (trap_on_stub_deopt, false,"put a break point before deoptimizing a stub") DEFINE_bool(deoptimize_uncommon_cases
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases	DEFINE_bool (polymorphic_inlining, true,"polymorphic inlining") DEFINE_bool(use_osr
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement	DEFINE_bool (array_bounds_checks_elimination, true,"perform array bounds checks elimination") DEFINE_bool(trace_bce
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination	DEFINE_bool (array_bounds_checks_hoisting, false,"perform array bounds checks hoisting") DEFINE_bool(array_index_dehoisting
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting	DEFINE_bool (analyze_environment_liveness, true,"analyze liveness of environment slots and zap dead values") DEFINE_bool(load_elimination
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination	DEFINE_bool (check_elimination, true,"use check elimination") DEFINE_bool(store_elimination
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination	DEFINE_bool (dead_code_elimination, true,"use dead code elimination") DEFINE_bool(fold_constants
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding	DEFINE_bool (trace_dead_code_elimination, false,"trace dead code elimination") DEFINE_bool(unreachable_code_elimination
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code	DEFINE_bool (trace_osr, false,"trace on-stack replacement") DEFINE_int(stress_runs
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs	DEFINE_bool (optimize_closures, true,"optimize closures") DEFINE_bool(lookup_sample_by_shared
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself	DEFINE_bool (cache_optimized_code, true,"cache optimized code for closures") DEFINE_bool(flush_optimized_code_cache
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC	DEFINE_bool (inline_construct, true,"inline constructor calls") DEFINE_bool(inline_arguments
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object	DEFINE_bool (inline_accessors, true,"inline JavaScript accessors") DEFINE_int(escape_analysis_iterations
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations	DEFINE_bool (optimize_for_in, true,"optimize functions containing for-in loops") DEFINE_bool(opt_safe_uint32_operations
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations	DEFINE_bool (concurrent_recompilation, true,"optimizing hot functions asynchronously on a separate thread") DEFINE_bool(trace_concurrent_recompilation
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation	DEFINE_int (concurrent_recompilation_queue_length, 8,"the length of the concurrent compilation queue") DEFINE_int(concurrent_recompilation_delay
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms	DEFINE_bool (block_concurrent_recompilation, false,"block queued jobs until released") DEFINE_bool(concurrent_osr
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement	DEFINE_implication (concurrent_osr, concurrent_recompilation) DEFINE_bool(omit_map_checks_for_leaf_maps
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes	DEFINE_int (typed_array_max_size_in_heap, 64,"threshold for in-heap typed array") DEFINE_int(frame_count
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler	DEFINE_int (interrupt_budget, 0x1800,"execution budget before interrupt is triggered") DEFINE_int(type_info_threshold
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization	DEFINE_int (self_opt_count, 130,"call count before self-optimization") DEFINE_bool(trace_opt_verbose
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing	DEFINE_implication (trace_opt_verbose, trace_opt) DEFINE_bool(debug_code
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra	code (assertions) for debugging") DEFINE_bool(code_comments
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly	DEFINE_bool (enable_sse2, true,"enable use of SSE2 instructions if available") DEFINE_bool(enable_sse3
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available	DEFINE_bool (enable_sse4_1, true,"enable use of SSE4.1 instructions if available") DEFINE_bool(enable_cmov
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available	DEFINE_bool (enable_sahf, true,"enable use of SAHF instruction if available (X64 only)") DEFINE_bool(enable_vfp3
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available	DEFINE_bool (enable_armv7, ENABLE_ARMV7_DEFAULT,"enable use of ARMv7 instructions if available (ARM only)") DEFINE_bool(enable_neon
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if	available (ARM only)") DEFINE_bool(enable_sudiv
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction	pairs (ARM only)") DEFINE_bool(enable_unaligned_accesses
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for	ARMv7 (ARM only)") DEFINE_bool(enable_32dregs
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3	DEFINE_bool (enable_vldr_imm, false,"enable use of constant pools for double immediate (ARM only)") DEFINE_bool(force_long_branches
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long	mode (MIPS only)") DEFINE_string(expose_natives_as
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object	DEFINE_string (expose_debug_as, NULL,"expose debug in global object") DEFINE_bool(expose_free_buffer
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension	DEFINE_bool (expose_gc, false,"expose gc extension") DEFINE_string(expose_gc_as
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name	DEFINE_implication (expose_gc_as, expose_gc) DEFINE_bool(expose_externalize_string
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension	DEFINE_bool (expose_trigger_failure, false,"expose trigger-failure extension") DEFINE_int(stack_trace_limit
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture	DEFINE_bool (builtins_in_stack_traces, false,"show built-in functions in stack traces") DEFINE_bool(disable_native_files
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files	DEFINE_bool (inline_new, true,"use fast inline allocation") DEFINE_bool(trace_codegen
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated	DEFINE_bool (trace, false,"trace function calls") DEFINE_bool(mask_constants_with_cookie
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants	DEFINE_bool (lazy, true,"use lazy compilation") DEFINE_bool(trace_opt
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization	DEFINE_bool (trace_opt_stats, false,"trace lazy optimization statistics") DEFINE_bool(opt
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations	DEFINE_bool (always_opt, false,"always try to optimize functions") DEFINE_bool(always_osr
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions	DEFINE_bool (prepare_always_opt, false,"prepare for turning on always opt") DEFINE_bool(trace_deopt
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization	DEFINE_bool (trace_stub_failures, false,"trace deoptimization of generated code stubs") DEFINE_int(min_preparse_length
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing	DEFINE_bool (always_full_compiler, false,"try to use the dedicated run-once backend for all code") DEFINE_int(max_opt_count
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up	DEFINE_bool (compilation_cache, true,"enable compilation cache") DEFINE_bool(cache_prototype_transitions
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions	DEFINE_int (cpu_profiler_sampling_interval, 1000,"CPU profiler sampling interval in microseconds") DEFINE_bool(trace_debug_json
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response	DEFINE_bool (trace_js_array_abuse, false,"trace out-of-bounds accesses to JS arrays") DEFINE_bool(trace_external_array_abuse
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays	DEFINE_bool (trace_array_abuse, false,"trace out-of-bounds accesses to all arrays") DEFINE_implication(trace_array_abuse
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse	DEFINE_implication (trace_array_abuse, trace_external_array_abuse) DEFINE_bool(debugger_auto_break
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue	DEFINE_bool (enable_liveedit, true,"enable liveedit experimental feature") DEFINE_bool(hard_abort
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing	DEFINE_int (stack_size, kPointerSize *123,"default size of stack region v8 is allowed to use (in kBytes)") DEFINE_int(max_stack_trace_source_length
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace	DEFINE_bool (always_inline_smi_code, false,"always inline smi code in non-opt code") DEFINE_int(max_new_space_size
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new	generation (in kBytes)") DEFINE_int(max_old_space_size
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable	memory (in Mbytes)") DEFINE_bool(gc_global
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs	DEFINE_int (gc_interval,-1,"garbage collect after <n> allocations") DEFINE_bool(trace_gc
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection	DEFINE_bool (trace_gc_nvp, false,"print one detailed trace line in name=value format ""after each garbage collection") DEFINE_bool(trace_gc_ignore_scavenger
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection	DEFINE_bool (print_cumulative_gc_stat, false,"print cumulative GC statistics in name=value format on exit") DEFINE_bool(print_max_heap_committed
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers	DEFINE_bool (log_colour, true,"When logging, try to use coloured output.") DEFINE_bool(ignore_asm_unimplemented_break
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros	DEFINE_bool (trace_sim_messages, false,"Trace simulator debug messages. Implied by --trace-sim.") DEFINE_bool(stack_trace_on_illegal
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown	DEFINE_bool (abort_on_uncaught_exception, false,"abort program (dump core) when an uncaught exception is thrown") DEFINE_bool(randomize_hashes
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash	collisions (with snapshots this option cannot override the baked-in seed)") DEFINE_int(hash_seed
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property	keys (0 means random)" "(with snapshots this option cannot override the baked-in seed)") DEFINE_bool(profile_deserialization
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot	DEFINE_bool (regexp_optimization, true,"generate optimized regexp code") DEFINE_bool(testing_bool_flag
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag	DEFINE_maybe_bool (testing_maybe_bool_flag,"testing_maybe_bool_flag") DEFINE_int(testing_int_flag
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag	DEFINE_float (testing_float_flag, 2.5,"float-flag") DEFINE_string(testing_string_flag
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag	DEFINE_int (testing_prng_seed, 42,"Seed used for threading test randomness") DEFINE_string(testing_serialization_file
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap	DEFINE_string (extra_code, NULL,"A filename with extra code to be included in"" the snapshot (mksnapshot only)") DEFINE_bool(profile_hydrogen_code_stub_compilation
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs	DEFINE_bool (predictable, false,"enable predictable mode") DEFINE_neg_implication(predictable
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation	DEFINE_neg_implication (predictable, concurrent_osr) DEFINE_neg_implication(predictable
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping	DEFINE_neg_implication (predictable, parallel_sweeping) DEFINE_bool(help
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console	DEFINE_bool (dump_counters, false,"Dump counters on exit") DEFINE_string(map_counters
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file	DEFINE_args (js_arguments,"Pass all remaining arguments to the script. Alias for \"--\".") DEFINE_bool(debug_compile_events
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events	DEFINE_bool (debug_script_collected_events, true,"Enable debugger script collected events") DEFINE_bool(gdbjit
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT	interface (disables compacting GC)") DEFINE_bool(gdbjit_full
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects	DEFINE_bool (gdbjit_dump, false,"dump elf objects with debug info to disk") DEFINE_string(gdbjit_dump_filter
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring	DEFINE_bool (force_marking_deque_overflows, false,"force overflows of marking deque by reducing it's size ""to 64 words") DEFINE_bool(stress_compaction
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out	bugs (implies" "--force_marking_deque_overflows)") DEFINE_bool(print_source
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code	DEFINE_bool (print_builtin_source, false,"pretty print source code for builtins") DEFINE_bool(print_ast
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST	DEFINE_bool (print_builtin_ast, false,"print source AST for builtins") DEFINE_string(stop_at
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint	DEFINE_bool (trap_on_abort, false,"replace aborts by breakpoints") DEFINE_bool(print_builtin_scopes
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins	DEFINE_bool (print_scopes, false,"print scopes") DEFINE_bool(trace_contexts
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations	DEFINE_bool (gc_greedy, false,"perform GC prior to some allocations") DEFINE_bool(gc_verbose
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection	DEFINE_bool (heap_stats, false,"report heap statistics before and after GC") DEFINE_bool(code_stats
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC	DEFINE_bool (verify_native_context_separation, false,"verify that code holds on to at most one native context after GC") DEFINE_bool(print_handles
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC	DEFINE_bool (print_global_handles, false,"report global handles after GC") DEFINE_bool(trace_ic
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions	DEFINE_bool (print_interfaces, false,"print interfaces") DEFINE_bool(print_interface_details
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details	DEFINE_int (print_interface_depth, 5,"depth for printing interfaces") DEFINE_bool(trace_normalization
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries	DEFINE_bool (trace_lazy, false,"trace lazy compilation") DEFINE_bool(collect_heap_spill_statistics
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with	heap_stats (requires heap_stats)") DEFINE_bool(trace_isolates
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes	DEFINE_bool (regexp_possessive_quantifier, false,"enable possessive quantifier syntax for testing") DEFINE_bool(trace_regexp_bytecodes
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution	DEFINE_bool (trace_regexp_assembler, false,"trace regexp macro assembler calls.") DEFINE_bool(log
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal	logging (no API, code, GC, suspect, or handles samples).") DEFINE_bool(log_all
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file	DEFINE_bool (log_runtime, false,"Activate runtime system %Log call.") DEFINE_bool(log_api
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file	DEFINE_bool (log_code, false,"Log code events to the log file without profiling.") DEFINE_bool(log_gc
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool	DEFINE_bool (log_handles, false,"Log global handle events.") DEFINE_bool(log_snapshot_positions
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions	of (de) serialized objects in the snapshot.") DEFINE_bool(log_suspect
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations	DEFINE_bool (prof, false,"Log statistical profiling information (implies --log-code).") DEFINE_bool(prof_browser_mode
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling	DEFINE_bool (log_regexp, false,"Log regular expression execution.") DEFINE_string(logfile
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file	DEFINE_bool (logfile_per_isolate, true,"Separate log files for each isolate.") DEFINE_bool(ll_prof
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler	DEFINE_bool (perf_basic_prof, false,"Enable perf linux profiler (basic support).") DEFINE_bool(perf_jit_prof
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux	profiler (experimental annotate support).") DEFINE_string(gc_fake_mmap
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof	DEFINE_bool (log_internal_timer_events, false,"Time internal events.") DEFINE_bool(log_timer_events
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks	DEFINE_implication (log_timer_events, log_internal_timer_events) DEFINE_implication(log_internal_timer_events
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof	DEFINE_bool (log_instruction_stats, false,"Log AArch64 instruction statistics.") DEFINE_string(log_instruction_file
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof arm64_inst AArch64 instruction statistics log file	DEFINE_int (log_instruction_period, 1<< 22,"AArch64 instruction statistics logging period.") DEFINE_bool(redirect_code_traces
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof arm64_inst AArch64 instruction statistics log file output deopt information and disassembly into file code< pid > < isolateid > asm	DEFINE_string (redirect_code_traces_to, NULL,"output deopt information and disassembly into the given file") DEFINE_bool(hydrogen_track_positions
	DEFINE_bool (trace_elements_transitions, false,"trace elements transitions") DEFINE_bool(trace_creation_allocation_sites
trace the creation of allocation sites	DEFINE_bool (print_code_stubs, false,"print code stubs") DEFINE_bool(test_secondary_stub_cache
trace the creation of allocation sites test secondary stub cache by disabling the primary one	DEFINE_bool (test_primary_stub_cache, false,"test primary stub cache by disabling the secondary one") DEFINE_bool(print_code
trace the creation of allocation sites test secondary stub cache by disabling the primary one print generated code	DEFINE_bool (print_opt_code, false,"print optimized code") DEFINE_bool(print_unopt_code
trace the creation of allocation sites test secondary stub cache by disabling the primary one print generated code print unoptimized code before printing optimized code based on it	DEFINE_bool (print_code_verbose, false,"print more information for code") DEFINE_bool(print_builtin_code
	DEFINE_bool (enable_ool_constant_pool, V8_OOL_CONSTANT_POOL,"enable use of out-of-line constant pools (ARM only)") DEFINE_bool(use_strict
enforce strict mode	DEFINE_bool (es_staging, false,"enable upcoming ES6+ features") DEFINE_bool(harmony_typeof
enforce strict mode enable harmony semantics for typeof	DEFINE_bool (harmony_scoping, false,"enable harmony block scoping") DEFINE_bool(harmony_modules
enforce strict mode enable harmony semantics for typeof enable harmony	modules (implies block scoping)") DEFINE_bool(harmony_symbols
char	NormalizeChar (char ch)
int	NumRegs (RegList reglist)
void	SetUpJSCallerSavedCodeData ()
Vector< StackFrame * >	CreateStackMap (Isolate *isolate, Zone *zone)
template<typename T >
void	USE (T)
template<typename F >
F	FUNCTION_CAST (Address addr)
Handle< FixedArray >	AddKeysFromJSArray (Handle< FixedArray > content, Handle< JSArray > array)
Handle< FixedArray >	UnionOfKeys (Handle< FixedArray > first, Handle< FixedArray > second)
Handle< JSGlobalProxy >	ReinitializeJSGlobalProxy (Handle< JSFunction > constructor, Handle< JSGlobalProxy > global)
void	FlattenString (Handle< String > string)
Handle< String >	FlattenGetString (Handle< String > string)
Handle< Object >	ForceSetProperty (Handle< JSObject > object, Handle< Object > key, Handle< Object > value, PropertyAttributes attributes)
Handle< Object >	DeleteProperty (Handle< JSObject > object, Handle< Object > key)
Handle< Object >	ForceDeleteProperty (Handle< JSObject > object, Handle< Object > key)
Handle< Object >	HasProperty (Handle< JSReceiver > obj, Handle< Object > key)
Handle< Object >	GetProperty (Handle< JSReceiver > obj, const char *name)
Handle< Object >	GetProperty (Isolate *isolate, Handle< Object > obj, Handle< Object > key)
Handle< String >	LookupSingleCharacterStringFromCode (Isolate *isolate, uint32_t index)
Handle< JSValue >	GetScriptWrapper (Handle< Script > script)
void	InitScriptLineEnds (Handle< Script > script)
Handle< FixedArray >	CalculateLineEnds (Handle< String > src, bool with_last_line)
int	GetScriptLineNumber (Handle< Script > script, int code_pos)
int	GetScriptColumnNumber (Handle< Script > script, int code_pos)
int	GetScriptLineNumberSafe (Handle< Script > script, int code_pos)
v8::Handle< v8::Array >	GetKeysForNamedInterceptor (Handle< JSReceiver > receiver, Handle< JSObject > object)
v8::Handle< v8::Array >	GetKeysForIndexedInterceptor (Handle< JSReceiver > receiver, Handle< JSObject > object)
Handle< Object >	GetScriptNameOrSourceURL (Handle< Script > script)
Handle< FixedArray >	GetKeysInFixedArrayFor (Handle< JSReceiver > object, KeyCollectionType type, bool *threw)
Handle< JSArray >	GetKeysFor (Handle< JSReceiver > object, bool *threw)
Handle< FixedArray >	ReduceFixedArrayTo (Handle< FixedArray > array, int length)
Handle< FixedArray >	GetEnumPropertyKeys (Handle< JSObject > object, bool cache_result)
void	AddWeakObjectToCodeDependency (Heap *heap, Handle< Object > object, Handle< Code > code)
template<class T >
Handle< T >	handle (T *t, Isolate *isolate)
template<class T >
Handle< T >	handle (T *t)
	STATIC_ASSERT ((FixedDoubleArray::kHeaderSize &kDoubleAlignmentMask)==0)
	STATIC_ASSERT ((ConstantPoolArray::kHeaderSize &kDoubleAlignmentMask)==0)
	INLINE (static HeapObject *EnsureDoubleAligned(Heap *heap, HeapObject *object, int size))
	V8_DECLARE_ONCE (initialize_gc_once)
void	TraceGVN (const char *msg,...)
bool	ConstantIsObject (HConstant *constant, Isolate *isolate)
	DEFINE_NEW_H_BITWISE_INSTR (HSar, c_left->NumberValueAsInteger32() >>(c_right->NumberValueAsInteger32()&0x1f)) DEFINE_NEW_H_BITWISE_INSTR(HShl
c_left	NumberValueAsInteger32 ()<< (c_right-> NumberValueAsInteger32()&0x1f)) HInstruction *HShr::New(Zone *zone, HValue *context, HValue *left, HValue *right)
bool	StoringValueNeedsWriteBarrier (HValue *value)
bool	ReceiverObjectNeedsWriteBarrier (HValue *object, HValue *value, HValue *new_space_dominator)
bool	CanBeZero (HValue *right)
template<class T >
void	DeleteNativeObjectAt (const v8::WeakCallbackData< v8::Value, void > &data, int index)
void	ArrayNativeCode (MacroAssembler *masm, bool construct_call, Label *call_generic_code)
bool	AreAliased (Register r1, Register r2, Register r3, Register r4)
Operand	FieldOperand (Register object, int offset)
Operand	FieldOperand (Register object, Register index, ScaleFactor scale, int offset)
Operand	FixedArrayElementOperand (Register array, Register index_as_smi, int additional_offset=0)
Operand	ApiParameterOperand (int index)
bool	IsOutOfBoundsAccess (Handle< JSObject > receiver, int index)
	RUNTIME_FUNCTION (MaybeObject *, LoadIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, KeyedLoadIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, KeyedLoadIC_MissFromStubFailure)
	RUNTIME_FUNCTION (MaybeObject *, StoreIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, StoreIC_MissFromStubFailure)
	RUNTIME_FUNCTION (MaybeObject *, StoreIC_ArrayLength)
	RUNTIME_FUNCTION (MaybeObject *, SharedStoreIC_ExtendStorage)
	RUNTIME_FUNCTION (MaybeObject *, KeyedStoreIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, KeyedStoreIC_MissFromStubFailure)
	RUNTIME_FUNCTION (MaybeObject *, StoreIC_Slow)
	RUNTIME_FUNCTION (MaybeObject *, KeyedStoreIC_Slow)
	RUNTIME_FUNCTION (MaybeObject *, ElementsTransitionAndStoreIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, BinaryOpIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, BinaryOpIC_MissWithAllocationSite)
	RUNTIME_FUNCTION (Code *, CompareIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, CompareNilIC_Miss)
	RUNTIME_FUNCTION (MaybeObject *, Unreachable)
	RUNTIME_FUNCTION (MaybeObject *, ToBooleanIC_Miss)
void	PatchInlinedSmiCode (Address address, InlinedSmiCheck check)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, KeyedLoadIC_MissFromStubFailure)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, KeyedStoreIC_MissFromStubFailure)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, UnaryOpIC_Miss)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, StoreIC_MissFromStubFailure)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, ElementsTransitionAndStoreIC_Miss)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, BinaryOpIC_Miss)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, BinaryOpIC_MissWithAllocationSite)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, CompareNilIC_Miss)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, ToBooleanIC_Miss)
bool	InitializeICU (const char *icu_data_file)
template<typename StringType >
void	SeqStringSet (Handle< StringType > seq_str, int i, uc32 c)
template<>
void	SeqStringSet (Handle< SeqTwoByteString > seq_str, int i, uc32 c)
template<>
void	SeqStringSet (Handle< SeqOneByteString > seq_str, int i, uc32 c)
template<typename StringType >
Handle< StringType >	NewRawString (Factory *factory, int length, PretenureFlag pretenure)
template<>
Handle< SeqTwoByteString >	NewRawString (Factory *factory, int length, PretenureFlag pretenure)
template<>
Handle< SeqOneByteString >	NewRawString (Factory *factory, int length, PretenureFlag pretenure)
ContainedInLattice	AddRange (ContainedInLattice containment, const int *ranges, int ranges_length, Interval new_range)
	STATIC_ASSERT (BoyerMoorePositionInfo::kMapSize==RegExpMacroAssembler::kTableSize)
ContainedInLattice	Combine (ContainedInLattice a, ContainedInLattice b)
template<typename T , typename P >
int	SortedListBSearch (const List< T > &list, P cmp)
template<typename T >
int	SortedListBSearch (const List< T > &list, T elem)
template<typename T , class P >
size_t	GetMemoryUsedByList (const List< T, P > &list)
	STATIC_ASSERT (DoubleRegister::kMaxNumAllocatableRegisters >=Register::kMaxNumAllocatableRegisters)
int	StackSlotOffset (int index)
const char *	AllocationSpaceName (AllocationSpace space)
template intptr_t	MarkCompactCollector::SweepConservatively< MarkCompactCollector::SWEEP_SEQUENTIALLY > (PagedSpace *, FreeList *, Page *)
template intptr_t	MarkCompactCollector::SweepConservatively< MarkCompactCollector::SWEEP_IN_PARALLEL > (PagedSpace *, FreeList *, Page *)
	REGISTER (no_reg,-1)
	REGISTER (zero_reg, 0)
	REGISTER (at, 1)
	REGISTER (v0, 2)
	REGISTER (v1, 3)
	REGISTER (a0, 4)
	REGISTER (a1, 5)
	REGISTER (a2, 6)
	REGISTER (a3, 7)
	REGISTER (t0, 8)
	REGISTER (t1, 9)
	REGISTER (t2, 10)
	REGISTER (t3, 11)
	REGISTER (t4, 12)
	REGISTER (t5, 13)
	REGISTER (t6, 14)
	REGISTER (t7, 15)
	REGISTER (s0, 16)
	REGISTER (s1, 17)
	REGISTER (s2, 18)
	REGISTER (s3, 19)
	REGISTER (s4, 20)
	REGISTER (s5, 21)
	REGISTER (s6, 22)
	REGISTER (s7, 23)
	REGISTER (t8, 24)
	REGISTER (t9, 25)
	REGISTER (k0, 26)
	REGISTER (k1, 27)
	REGISTER (gp, 28)
	REGISTER (sp, 29)
	REGISTER (fp, 30)
	REGISTER (ra, 31)
int	ToNumber (Register reg)
Register	ToRegister (int num)
	STATIC_ASSERT (kMaxWatchpointCode< kMaxStopCode)
MemOperand	CFunctionArgumentOperand (int index)
int	IntegerLog2 (uint32_t value)
	STATIC_CHECK ((kStringRepresentationMask|kStringEncodingMask)==Internals::kFullStringRepresentationMask)
	STATIC_CHECK (static_cast< uint32_t >(kStringEncodingMask)==Internals::kStringEncodingMask)
	STATIC_CHECK ((kExternalStringTag|kOneByteStringTag)==Internals::kExternalAsciiRepresentationTag)
	STATIC_CHECK (v8::String::ASCII_ENCODING==kOneByteStringTag)
	STATIC_CHECK ((kExternalStringTag|kTwoByteStringTag)==Internals::kExternalTwoByteRepresentationTag)
	STATIC_CHECK (v8::String::TWO_BYTE_ENCODING==kTwoByteStringTag)
template<>
bool	Is< JSFunction > (Object *obj)
template<>
bool	Is< JSArray > (Object *obj)
	SMI_ACCESSORS (ConstantPoolArray, first_code_ptr_index, kFirstCodePointerIndexOffset) SMI_ACCESSORS(ConstantPoolArray
kFirstHeapPointerIndexOffset	SMI_ACCESSORS (ConstantPoolArray, first_int32_index, kFirstInt32IndexOffset) int ConstantPoolArray
template<SearchMode search_mode, typename T >
int	BinarySearch (T *array, Name *name, int low, int high, int valid_entries)
template<SearchMode search_mode, typename T >
int	LinearSearch (T *array, Name *name, int len, int valid_entries)
template<SearchMode search_mode, typename T >
int	Search (T *array, Name *name, int valid_entries)
	ACCESSORS (AccessorInfo, expected_receiver_type, Object, kExpectedReceiverTypeOffset) ACCESSORS(DeclaredAccessorDescriptor
kSerializedDataOffset	ACCESSORS (DeclaredAccessorInfo, descriptor, DeclaredAccessorDescriptor, kDescriptorOffset) ACCESSORS(FunctionTemplateInfo
kSerializedDataOffset kPrototypeTemplateOffset	ACCESSORS (FunctionTemplateInfo, named_property_handler, Object, kNamedPropertyHandlerOffset) ACCESSORS(FunctionTemplateInfo
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset	ACCESSORS (FunctionTemplateInfo, instance_template, Object, kInstanceTemplateOffset) ACCESSORS(FunctionTemplateInfo
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset	ACCESSORS (FunctionTemplateInfo, access_check_info, Object, kAccessCheckInfoOffset) ACCESSORS(ObjectTemplateInfo
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset	ACCESSORS_TO_SMI (AllocationSite, pretenure_create_count, kPretenureCreateCountOffset) ACCESSORS(AllocationSite
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset kDependentCodeOffset	ACCESSORS_TO_SMI (Script, eval_from_instructions_offset, kEvalFrominstructionsOffsetOffset) Script
	ACCESSORS (SharedFunctionInfo, optimized_code_map, Object, kOptimizedCodeMapOffset) ACCESSORS(SharedFunctionInfo
kInstanceClassNameOffset	BOOL_ACCESSORS (FunctionTemplateInfo, flag, hidden_prototype, kHiddenPrototypeBit) BOOL_ACCESSORS(FunctionTemplateInfo
kInstanceClassNameOffset kNeedsAccessCheckBit	BOOL_ACCESSORS (FunctionTemplateInfo, flag, read_only_prototype, kReadOnlyPrototypeBit) BOOL_ACCESSORS(FunctionTemplateInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit	BOOL_ACCESSORS (FunctionTemplateInfo, flag, do_not_cache, kDoNotCacheBit) BOOL_ACCESSORS(SharedFunctionInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit	BOOL_ACCESSORS (SharedFunctionInfo, start_position_and_type, is_toplevel, kIsTopLevelBit) BOOL_ACCESSORS(SharedFunctionInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation	BOOL_ACCESSORS (SharedFunctionInfo, compiler_hints, allows_lazy_compilation_without_context, kAllowLazyCompilationWithoutContext) BOOL_ACCESSORS(SharedFunctionInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments	BOOL_ACCESSORS (SharedFunctionInfo, compiler_hints, has_duplicate_parameters, kHasDuplicateParameters) PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset	PSEUDO_SMI_ACCESSORS_LO (SharedFunctionInfo, expected_nof_properties, kExpectedNofPropertiesOffset) PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset kStartPositionAndTypeOffset	PSEUDO_SMI_ACCESSORS_LO (SharedFunctionInfo, function_token_position, kFunctionTokenPositionOffset) PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset kStartPositionAndTypeOffset kCompilerHintsOffset	PSEUDO_SMI_ACCESSORS_LO (SharedFunctionInfo, opt_count_and_bailout_reason, kOptCountAndBailoutReasonOffset) int SharedFunctionInfo
	BOOL_ACCESSORS (SharedFunctionInfo, compiler_hints, live_objects_may_exist, kLiveObjectsMayExist) bool SharedFunctionInfo
	BOOL_GETTER (SharedFunctionInfo, compiler_hints, optimization_disabled, kOptimizationDisabled) void SharedFunctionInfo
	BOOL_ACCESSORS (SharedFunctionInfo, compiler_hints, inline_builtin, kInlineBuiltin) BOOL_ACCESSORS(SharedFunctionInfo
kNameShouldPrintAsAnonymous	BOOL_ACCESSORS (SharedFunctionInfo, compiler_hints, dont_optimize, kDontOptimize) void SharedFunctionInfo
	ACCESSORS (JSFunction, prototype_or_initial_map, Object, kPrototypeOrInitialMapOffset) Map *JSFunction
	ACCESSORS (TypeFeedbackInfo, feedback_vector, FixedArray, kFeedbackVectorOffset) Relocatable
Handle< NameDictionary >	NameDictionaryShrink (Handle< NameDictionary > dict, Handle< Name > name)
Handle< Object >	CacheInitialJSArrayMaps (Handle< Context > native_context, Handle< Map > initial_map)
void	HeapSortPairs (FixedArray *content, FixedArray *numbers, int len)
const char *	GetBailoutReason (BailoutReason reason)
	STATIC_ASSERT (STANDARD_STORE==0)
	STATIC_ASSERT (kGrowICDelta==STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT-STORE_TRANSITION_SMI_TO_OBJECT)
	STATIC_ASSERT ((kSeqStringTag &kIsIndirectStringMask)==0)
	STATIC_ASSERT ((kExternalStringTag &kIsIndirectStringMask)==0)
	STATIC_ASSERT ((kConsStringTag &kIsIndirectStringMask)==kIsIndirectStringTag)
	STATIC_ASSERT ((kSlicedStringTag &kIsIndirectStringMask)==kIsIndirectStringTag)
	STATIC_ASSERT (IS_POWER_OF_TWO(kSlicedNotConsMask)&&kSlicedNotConsMask!=0)
	STATIC_CHECK (JS_OBJECT_TYPE==Internals::kJSObjectType)
	STATIC_CHECK (FIRST_NONSTRING_TYPE==Internals::kFirstNonstringType)
	STATIC_CHECK (ODDBALL_TYPE==Internals::kOddballType)
	STATIC_CHECK (FOREIGN_TYPE==Internals::kForeignType)
template<class C >
bool	Is (Object *obj)
void	CallOnceImpl (OnceType *once, PointerArgFunction init_func, void *arg)
void	CallOnce (OnceType *once, NoArgFunction init_func)
template<typename Arg >
void	CallOnce (OnceType *once, typename OneArgFunction< Arg * >::type init_func, Arg *arg)
Time	operator+ (const TimeDelta &delta, const Time &time)
TimeTicks	operator+ (const TimeDelta &delta, const TimeTicks &ticks)
double	modulo (double x, double y)
void	lazily_initialize_fast_exp ()
void	MathSetup ()
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymInitialize))(IN HANDLE hProcess
typedef	DWORD (__stdcall *DLL_FUNC_TYPE(SymGetOptions))(VOID)
typedef	DWORD (__stdcall *DLL_FUNC_TYPE(SymSetOptions))(IN DWORD SymOptions)
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSearchPath))(IN HANDLE hProcess
typedef	DWORD64 (__stdcall *DLL_FUNC_TYPE(SymLoadModule64))(IN HANDLE hProcess
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(StackWalk64))(DWORD MachineType
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSymFromAddr64))(IN HANDLE hProcess
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymGetLineFromAddr64))(IN HANDLE hProcess
typedef	PVOID (__stdcall *DLL_FUNC_TYPE(SymFunctionTableAccess64))(HANDLE hProcess
typedef	DWORD64 (__stdcall *DLL_FUNC_TYPE(SymGetModuleBase64))(HANDLE hProcess
typedef	HANDLE (__stdcall *DLL_FUNC_TYPE(CreateToolhelp32Snapshot))(DWORD dwFlags
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(Module32FirstW))(HANDLE hSnapshot
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(Module32NextW))(HANDLE hSnapshot
double	fast_exp (double input)
double	fast_sqrt (double input)
MaybeObject *	TransitionElements (Handle< Object > object, ElementsKind to_kind, Isolate *isolate)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_CreateObjectLiteral)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_CreateArrayLiteral)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_CreateArrayLiteralStubBailout)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CreateSymbol)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CreatePrivateSymbol)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CreateGlobalPrivateSymbol)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NewSymbolWrapper)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SymbolDescription)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SymbolRegistry)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SymbolIsPrivate)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CreateJSProxy)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CreateJSFunctionProxy)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsJSProxy)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsJSFunctionProxy)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetHandler)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetCallTrap)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetConstructTrap)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Fix)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ArrayBufferInitialize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ArrayBufferGetByteLength)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ArrayBufferSliceImpl)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ArrayBufferIsView)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ArrayBufferNeuter)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TypedArrayInitialize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TypedArrayInitializeFromArrayLike)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TypedArrayGetBuffer)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TypedArraySetFastCases)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TypedArrayMaxSizeInHeap)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DataViewInitialize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DataViewGetBuffer)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DataViewGetByteOffset)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DataViewGetByteLength)
template<int n>
void	CopyBytes (uint8_t *target, uint8_t *source)
template<int n>
void	FlipBytes (uint8_t *target, uint8_t *source)
template<>
int8_t	DataViewConvertValue< int8_t > (double value)
template<>
int16_t	DataViewConvertValue< int16_t > (double value)
template<>
int32_t	DataViewConvertValue< int32_t > (double value)
template<>
uint8_t	DataViewConvertValue< uint8_t > (double value)
template<>
uint16_t	DataViewConvertValue< uint16_t > (double value)
template<>
uint32_t	DataViewConvertValue< uint32_t > (double value)
template<>
float	DataViewConvertValue< float > (double value)
template<>
double	DataViewConvertValue< double > (double value)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetInitialize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetAdd)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetHas)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetDelete)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetGetSize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MapInitialize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MapGet)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MapHas)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MapDelete)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MapSet)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MapGetSize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_WeakCollectionInitialize)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_WeakCollectionGet)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_WeakCollectionHas)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_WeakCollectionDelete)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_WeakCollectionSet)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ClassOf)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetPrototype)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetPrototype)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsInPrototypeChain)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetOwnProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_PreventExtensions)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsExtensible)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RegExpCompile)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CreateApiFunction)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsTemplate)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetTemplateField)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DisableAccessChecks)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_EnableAccessChecks)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetAccessorProperty)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_DeclareGlobals)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_DeclareContextSlot)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_InitializeVarGlobal)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_InitializeConstGlobal)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_InitializeConstContextSlot)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_OptimizeObjectForAddingMultipleProperties)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_RegExpExec)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_RegExpConstructResult)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RegExpInitializeObject)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FinishArrayPrototypeSetup)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SpecialArrayFunctions)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsSloppyModeFunction)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetDefaultReceiver)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_MaterializeRegExpLiteral)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionGetName)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionSetName)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionNameShouldPrintAsAnonymous)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionMarkNameShouldPrintAsAnonymous)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionIsGenerator)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionRemovePrototype)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionGetScript)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionGetSourceCode)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionGetScriptSourcePosition)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionGetPositionForOffset)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionSetInstanceClassName)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionSetLength)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionSetPrototype)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionSetReadOnlyPrototype)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionIsAPIFunction)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionIsBuiltin)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetCode)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetExpectedNumberOfProperties)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_CreateJSGeneratorObject)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_SuspendJSGeneratorObject)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ResumeJSGeneratorObject)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ThrowGeneratorStateError)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ObjectFreeze)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_StringCharCodeAt)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CharFromCode)
void	FindAsciiStringIndices (Vector< const uint8_t > subject, char pattern, ZoneList< int > *indices, unsigned int limit, Zone *zone)
void	FindTwoByteStringIndices (const Vector< const uc16 > subject, uc16 pattern, ZoneList< int > *indices, unsigned int limit, Zone *zone)
template<typename SubjectChar , typename PatternChar >
void	FindStringIndices (Isolate *isolate, Vector< const SubjectChar > subject, Vector< const PatternChar > pattern, ZoneList< int > *indices, unsigned int limit, Zone *zone)
void	FindStringIndicesDispatch (Isolate *isolate, String *subject, String *pattern, ZoneList< int > *indices, unsigned int limit, Zone *zone)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringReplaceGlobalRegExpWithString)
Handle< String >	StringReplaceOneCharWithString (Isolate *isolate, Handle< String > subject, Handle< String > search, Handle< String > replace, bool *found, int recursion_limit)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringReplaceOneCharWithString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringIndexOf)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringLastIndexOf)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringLocaleCompare)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_SubString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringMatch)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RegExpExecMultiple)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToRadixString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToFixed)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToExponential)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToPrecision)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsValidSmi)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_KeyedGetProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DefineOrRedefineAccessorProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DefineOrRedefineDataProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetDataProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetHiddenProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TransitionElementsKind)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetNativeFlag)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetInlineBuiltinFlag)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StoreArrayLiteralElement)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DebugCallbackSupportsStepping)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DebugPrepareStepInIfStepping)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IgnoreAttributesAndSetProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DeleteProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_HasLocalProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_HasProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_HasElement)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsPropertyEnumerable)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetPropertyNames)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetPropertyNamesFast)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetLocalPropertyNames)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetLocalElementNames)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetInterceptorInfo)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetNamedInterceptorPropertyNames)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetIndexedInterceptorElementNames)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_LocalKeys)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetArgumentsProperty)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ToFastProperties)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ToBool)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Typeof)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringToNumber)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NewString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TruncateString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_URIEscape)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_URIUnescape)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_QuoteJSONString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_BasicJSONStringify)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringParseInt)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringParseFloat)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringToLowerCase)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringToUpperCase)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringTrim)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringSplit)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringToArray)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NewStringWrapper)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NumberToString)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NumberToStringSkipCache)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToInteger)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToIntegerMapMinusZero)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToJSUint32)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberToJSInt32)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NumberToSmi)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_AllocateHeapNumber)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberAdd)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberSub)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberMul)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberUnaryMinus)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberAlloc)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberDiv)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberMod)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberImul)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_StringAdd)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringBuilderConcat)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringBuilderJoin)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SparseJoinWithSeparator)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberOr)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberAnd)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberXor)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberShl)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberShr)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberSar)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberEquals)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_StringEquals)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NumberCompare)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SmiLexicographicCompare)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_StringCompare)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DoubleHi)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DoubleLo)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ConstructDouble)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_atan2)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_exp)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_floor)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_pow)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_pow_cfunction)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RoundNumber)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_sqrt)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Math_fround)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateMakeDay)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateSetValue)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewArgumentsFast)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewStrictArgumentsFast)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewClosureFromStubFailure)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewClosure)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FunctionBindArguments)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_BoundFunctionGetBindings)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NewObjectFromBound)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewObject)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewObjectWithAllocationSite)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_FinalizeInstanceSize)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_CompileUnoptimized)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_CompileOptimized)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NotifyStubFailure)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NotifyDeoptimized)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DeoptimizeFunction)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ClearFunctionTypeFeedback)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RunningInSimulator)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsConcurrentRecompilationSupported)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_OptimizeFunctionOnNextCall)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NeverOptimizeFunction)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetOptimizationStatus)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_UnblockConcurrentRecompilation)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetOptimizationCount)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CompileForOnStackReplacement)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetAllocationTimeout)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CheckIsBootstrapping)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetRootNaN)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Call)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Apply)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetFunctionDelegate)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetConstructorDelegate)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewGlobalContext)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_NewFunctionContext)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_PushWithContext)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_PushCatchContext)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_PushBlockContext)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsJSModule)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_PushModuleContext)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_DeclareModules)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_DeleteContextSlot)
	RUNTIME_FUNCTION (ObjectPair, RuntimeHidden_LoadContextSlot)
	RUNTIME_FUNCTION (ObjectPair, RuntimeHidden_LoadContextSlotNoReferenceError)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_StoreContextSlot)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_Throw)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ReThrow)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_PromoteScheduledException)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ThrowReferenceError)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ThrowNotDateError)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ThrowMessage)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_StackGuard)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_TryInstallOptimizedCode)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_Interrupt)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TraceEnter)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TraceExit)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DebugPrint)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DebugTrace)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateCurrentTime)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateParseString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateLocalTimezone)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateToUTC)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_DateCacheVersion)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GlobalReceiver)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsAttachedGlobal)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ParseJson)
bool	CodeGenerationFromStringsAllowed (Isolate *isolate, Handle< Context > context)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CompileString)
	RUNTIME_FUNCTION (ObjectPair, RuntimeHidden_ResolvePossiblyDirectEval)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_AllocateInNewSpace)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_AllocateInTargetSpace)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_PushIfAbsent)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ArrayConcat)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GlobalPrint)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RemoveArrayHoles)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MoveArrayContents)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_EstimateNumberOfElements)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetArrayKeys)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_LookupAccessor)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetScript)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_CollectStackTrace)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetAndClearOverflowedStackTrace)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetV8Version)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_Abort)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_AbortJS)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_FlattenString)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_NotifyContextDisposed)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_TryMigrateInstance)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_GetFromCache)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MessageGetStartPosition)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MessageGetScript)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_Log)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IS_VAR)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_HaveSameMap)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsAccessCheckNeeded)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsObserved)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetIsObserved)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_SetMicrotaskPending)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_RunMicrotasks)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetMicrotaskState)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_GetObservationState)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_ObservationWeakMapCreate)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_UnwrapGlobalProxy)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_IsAccessAllowedForObserver)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_ArrayConstructor)
	RUNTIME_FUNCTION (MaybeObject *, RuntimeHidden_InternalArrayConstructor)
	RUNTIME_FUNCTION (MaybeObject *, Runtime_MaxSmi)
	STATIC_ASSERT (Token::NUM_TOKENS<=0x100)
int	HexValue (uc32 c)
	STATIC_CHECK (sizeof(MemoryChunk)<=MemoryChunk::kHeaderSize)
	STATIC_CHECK (sizeof(Page)<=MemoryChunk::kHeaderSize)
	STATIC_CHECK (sizeof(LargePage)<=MemoryChunk::kHeaderSize)
template<typename PatternChar , typename SubjectChar >
bool	CharCompare (const PatternChar *pattern, const SubjectChar *subject, int length)
template<typename SubjectChar , typename PatternChar >
int	SearchString (Isolate *isolate, Vector< const SubjectChar > subject, Vector< const PatternChar > pattern, int start_index)
double	Strtod (Vector< const char > buffer, int exponent)
	RUNTIME_FUNCTION (MaybeObject *, StoreCallbackProperty)
	RUNTIME_FUNCTION (MaybeObject *, LoadPropertyWithInterceptorOnly)
	RUNTIME_FUNCTION (MaybeObject *, LoadPropertyWithInterceptorForLoad)
	RUNTIME_FUNCTION (MaybeObject *, LoadPropertyWithInterceptorForCall)
	RUNTIME_FUNCTION (MaybeObject *, StoreInterceptorProperty)
	RUNTIME_FUNCTION (MaybeObject *, KeyedLoadPropertyWithInterceptor)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, StoreCallbackProperty)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, LoadPropertyWithInterceptorOnly)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, LoadPropertyWithInterceptorForLoad)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, LoadPropertyWithInterceptorForCall)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, StoreInterceptorProperty)
	DECLARE_RUNTIME_FUNCTION (MaybeObject *, KeyedLoadPropertyWithInterceptor)
template<>
Vector< const uint8_t >	GetCharVector (Handle< String > string)
template<>
Vector< const uc16 >	GetCharVector (Handle< String > string)
template<typename T >
bool	IsPowerOf2 (T x)
int	WhichPowerOf2 (uint32_t x)
int	MostSignificantBit (uint32_t x)
int	ArithmeticShiftRight (int x, int s)
template<typename T >
intptr_t	OffsetFrom (T x)
template<typename T >
T	AddressFrom (intptr_t x)
template<typename T >
T	RoundDown (T x, intptr_t m)
template<typename T >
T	RoundUp (T x, intptr_t m)
template<class T >
T	AlignUp (T pointer, size_t alignment)
template<typename T >
int	Compare (const T &a, const T &b)
template<typename T >
int	PointerValueCompare (const T *a, const T *b)
template<typename T >
int	HandleObjectPointerCompare (const Handle< T > *a, const Handle< T > *b)
uint32_t	RoundUpToPowerOf2 (uint32_t x)
uint32_t	RoundDownToPowerOf2 (uint32_t x)
template<typename T , typename U >
bool	IsAligned (T value, U alignment)
bool	IsAddressAligned (Address addr, intptr_t alignment, int offset=0)
template<typename T >
T	Max (T a, T b)
template<typename T >
T	Min (T a, T b)
template<typename T >
T	Abs (T a)
template<typename T >
T	NegAbs (T a)
int	StrLength (const char *string)
int32_t	WhichPowerOf2Abs (int32_t x)
uint32_t	ComputeIntegerHash (uint32_t key, uint32_t seed)
uint32_t	ComputeLongHash (uint64_t key)
uint32_t	ComputePointerHash (void *ptr)
Vector< const char >	CStrVector (const char *data)
Vector< const uint8_t >	OneByteVector (const char *data, int length)
Vector< const uint8_t >	OneByteVector (const char *data)
Vector< char >	MutableCStrVector (char *data)
Vector< char >	MutableCStrVector (char *data, int max)
template<typename lchar , typename rchar >
int	CompareCharsUnsigned (const lchar *lhs, const rchar *rhs, int chars)
template<typename lchar , typename rchar >
int	CompareChars (const lchar *lhs, const rchar *rhs, int chars)
int	TenToThe (int exponent)
template<class Dest , class Source >
	INLINE (Dest BitCast(const Source &source))
template<class Dest , class Source >
Dest	BitCast (const Source &source)
uint32_t	unsigned_bitextract_32 (int msb, int lsb, uint32_t x)
uint64_t	unsigned_bitextract_64 (int msb, int lsb, uint64_t x)
int32_t	signed_bitextract_32 (int msb, int lsb, int32_t x)
int	signed_bitextract_64 (int msb, int lsb, int x)
bool	is_intn (int64_t x, unsigned n)
bool	is_uintn (int64_t x, unsigned n)
template<class T >
T	truncate_to_intn (T x, unsigned n)
	V8_DECLARE_ONCE (init_once)
double	StringToDouble (UnicodeCache *unicode_cache, String *str, int flags, double empty_string_val)
double	StringToInt (UnicodeCache *unicode_cache, String *str, int radix)
int32_t	NumberToInt32 (Object *number)
uint32_t	NumberToUint32 (Object *number)
bool	TryNumberToSize (Isolate *isolate, Object *number, size_t *result)
size_t	NumberToSize (Isolate *isolate, Object *number)
bool	IsDynamicVariableMode (VariableMode mode)
bool	IsDeclaredVariableMode (VariableMode mode)
bool	IsLexicalVariableMode (VariableMode mode)
bool	IsImmutableVariableMode (VariableMode mode)
void	PrintF (const char *format,...)
void	PrintF (FILE *out, const char *format,...)
void	PrintPID (const char *format,...)
void	Flush (FILE *out)
char *	ReadLine (const char *prompt)
char *	ReadCharsFromFile (FILE *file, int *size, int extra_space, bool verbose, const char *filename)
char *	ReadCharsFromFile (const char *filename, int *size, int extra_space, bool verbose)
byte *	ReadBytes (const char *filename, int *size, bool verbose)
Vector< const char >	ReadFile (const char *filename, bool *exists, bool verbose)
Vector< const char >	ReadFile (FILE *file, bool *exists, bool verbose)
int	WriteCharsToFile (const char *str, int size, FILE *f)
int	AppendChars (const char *filename, const char *str, int size, bool verbose)
int	WriteChars (const char *filename, const char *str, int size, bool verbose)
int	WriteBytes (const char *filename, const byte *bytes, int size, bool verbose)
void	Flush ()
int	WriteAsCFile (const char *filename, const char *varname, const char *str, int size, bool verbose=true)
template<typename T >
Vector< Handle< Object > >	HandleVector (v8::internal::Handle< T > *elms, int length)
template<typename T >
void	CopyWords (T *dst, const T *src, size_t num_words)
template<typename T >
void	MoveWords (T *dst, const T *src, size_t num_words)
template<typename T >
void	CopyBytes (T *dst, const T *src, size_t num_bytes)
template<typename T , typename U >
void	MemsetPointer (T **dest, U *value, int counter)
template<typename sourcechar , typename sinkchar >
	INLINE (static void CopyCharsUnsigned(sinkchar *dest, const sourcechar *src, int chars))
template<typename sourcechar , typename sinkchar >
	INLINE (void CopyChars(sinkchar *dest, const sourcechar *src, int chars))
template<typename sourcechar , typename sinkchar >
void	CopyChars (sinkchar *dest, const sourcechar *src, int chars)
template<typename sourcechar , typename sinkchar >
void	CopyCharsUnsigned (sinkchar *dest, const sourcechar *src, int chars)
const char *	StateToString (StateTag state)
	STATIC_ASSERT (NUMBER_OF_CONSTRAINTS<=8)
Operand	StackSpaceOperand (int index)
Operand	StackOperandForReturnAddress (int32_t disp)
Vector< const PrecomputedFixed >	PrecomputedFixedRepresentations ()
Vector< const PrecomputedPrecision >	PrecomputedPrecisionRepresentations ()
Vector< const PrecomputedShortest >	PrecomputedShortestRepresentations ()
	TEST (Positions)
void	SetVersion (int major, int minor, int build, int patch, bool candidate, const char *soname)

Variables
const int	kApiPointerSize = sizeof(void*)
const int	kApiIntSize = sizeof(int)
const int	kHeapObjectTag = 1
const int	kHeapObjectTagSize = 2
const intptr_t	kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1
const int	kSmiTag = 0
const int	kSmiTagSize = 1
const intptr_t	kSmiTagMask = (1 << kSmiTagSize) - 1
const int	kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize
const int	kSmiValueSize = PlatformSmiTagging::kSmiValueSize
const int	kHandleBlockSize = v8::internal::KB - 2
const int	kRegister_no_reg_Code = -1
const int	kRegister_r0_Code = 0
const int	kRegister_r1_Code = 1
const int	kRegister_r2_Code = 2
const int	kRegister_r3_Code = 3
const int	kRegister_r4_Code = 4
const int	kRegister_r5_Code = 5
const int	kRegister_r6_Code = 6
const int	kRegister_r7_Code = 7
const int	kRegister_r8_Code = 8
const int	kRegister_r9_Code = 9
const int	kRegister_r10_Code = 10
const int	kRegister_fp_Code = 11
const int	kRegister_ip_Code = 12
const int	kRegister_sp_Code = 13
const int	kRegister_lr_Code = 14
const int	kRegister_pc_Code = 15
const Register	no_reg = { kRegister_no_reg_Code }
const Register	r0 = { kRegister_r0_Code }
const Register	r1 = { kRegister_r1_Code }
const Register	r2 = { kRegister_r2_Code }
const Register	r3 = { kRegister_r3_Code }
const Register	r4 = { kRegister_r4_Code }
const Register	r5 = { kRegister_r5_Code }
const Register	r6 = { kRegister_r6_Code }
const Register	r7 = { kRegister_r7_Code }
const Register	r8 = { kRegister_r8_Code }
const Register	r9 = { kRegister_r9_Code }
const Register	r10 = { kRegister_r10_Code }
const Register	fp = { kRegister_fp_Code }
const Register	ip = { kRegister_ip_Code }
const Register	sp = { kRegister_sp_Code }
const Register	lr = { kRegister_lr_Code }
const Register	pc = { kRegister_pc_Code }
const SwVfpRegister	s0 = { 0 }
const SwVfpRegister	s1 = { 1 }
const SwVfpRegister	s2 = { 2 }
const SwVfpRegister	s3 = { 3 }
const SwVfpRegister	s4 = { 4 }
const SwVfpRegister	s5 = { 5 }
const SwVfpRegister	s6 = { 6 }
const SwVfpRegister	s7 = { 7 }
const SwVfpRegister	s8 = { 8 }
const SwVfpRegister	s9 = { 9 }
const SwVfpRegister	s10 = { 10 }
const SwVfpRegister	s11 = { 11 }
const SwVfpRegister	s12 = { 12 }
const SwVfpRegister	s13 = { 13 }
const SwVfpRegister	s14 = { 14 }
const SwVfpRegister	s15 = { 15 }
const SwVfpRegister	s16 = { 16 }
const SwVfpRegister	s17 = { 17 }
const SwVfpRegister	s18 = { 18 }
const SwVfpRegister	s19 = { 19 }
const SwVfpRegister	s20 = { 20 }
const SwVfpRegister	s21 = { 21 }
const SwVfpRegister	s22 = { 22 }
const SwVfpRegister	s23 = { 23 }
const SwVfpRegister	s24 = { 24 }
const SwVfpRegister	s25 = { 25 }
const SwVfpRegister	s26 = { 26 }
const SwVfpRegister	s27 = { 27 }
const SwVfpRegister	s28 = { 28 }
const SwVfpRegister	s29 = { 29 }
const SwVfpRegister	s30 = { 30 }
const SwVfpRegister	s31 = { 31 }
const DwVfpRegister	no_dreg = { -1 }
const LowDwVfpRegister	d0 = { 0 }
const LowDwVfpRegister	d1 = { 1 }
const LowDwVfpRegister	d2 = { 2 }
const LowDwVfpRegister	d3 = { 3 }
const LowDwVfpRegister	d4 = { 4 }
const LowDwVfpRegister	d5 = { 5 }
const LowDwVfpRegister	d6 = { 6 }
const LowDwVfpRegister	d7 = { 7 }
const LowDwVfpRegister	d8 = { 8 }
const LowDwVfpRegister	d9 = { 9 }
const LowDwVfpRegister	d10 = { 10 }
const LowDwVfpRegister	d11 = { 11 }
const LowDwVfpRegister	d12 = { 12 }
const LowDwVfpRegister	d13 = { 13 }
const LowDwVfpRegister	d14 = { 14 }
const LowDwVfpRegister	d15 = { 15 }
const DwVfpRegister	d16 = { 16 }
const DwVfpRegister	d17 = { 17 }
const DwVfpRegister	d18 = { 18 }
const DwVfpRegister	d19 = { 19 }
const DwVfpRegister	d20 = { 20 }
const DwVfpRegister	d21 = { 21 }
const DwVfpRegister	d22 = { 22 }
const DwVfpRegister	d23 = { 23 }
const DwVfpRegister	d24 = { 24 }
const DwVfpRegister	d25 = { 25 }
const DwVfpRegister	d26 = { 26 }
const DwVfpRegister	d27 = { 27 }
const DwVfpRegister	d28 = { 28 }
const DwVfpRegister	d29 = { 29 }
const DwVfpRegister	d30 = { 30 }
const DwVfpRegister	d31 = { 31 }
const QwNeonRegister	q0 = { 0 }
const QwNeonRegister	q1 = { 1 }
const QwNeonRegister	q2 = { 2 }
const QwNeonRegister	q3 = { 3 }
const QwNeonRegister	q4 = { 4 }
const QwNeonRegister	q5 = { 5 }
const QwNeonRegister	q6 = { 6 }
const QwNeonRegister	q7 = { 7 }
const QwNeonRegister	q8 = { 8 }
const QwNeonRegister	q9 = { 9 }
const QwNeonRegister	q10 = { 10 }
const QwNeonRegister	q11 = { 11 }
const QwNeonRegister	q12 = { 12 }
const QwNeonRegister	q13 = { 13 }
const QwNeonRegister	q14 = { 14 }
const QwNeonRegister	q15 = { 15 }
const CRegister	no_creg = { -1 }
const CRegister	cr0 = { 0 }
const CRegister	cr1 = { 1 }
const CRegister	cr2 = { 2 }
const CRegister	cr3 = { 3 }
const CRegister	cr4 = { 4 }
const CRegister	cr5 = { 5 }
const CRegister	cr6 = { 6 }
const CRegister	cr7 = { 7 }
const CRegister	cr8 = { 8 }
const CRegister	cr9 = { 9 }
const CRegister	cr10 = { 10 }
const CRegister	cr11 = { 11 }
const CRegister	cr12 = { 12 }
const CRegister	cr13 = { 13 }
const CRegister	cr14 = { 14 }
const CRegister	cr15 = { 15 }
const Instr	kMovLrPc
const Instr	kLdrPCMask
const Instr	kLdrPCPattern
const Instr	kLdrPpMask
const Instr	kLdrPpPattern
const Instr	kBlxRegMask
const Instr	kBlxRegPattern
const Instr	kBlxIp
const Instr	kMovMvnMask
const Instr	kMovMvnPattern
const Instr	kMovMvnFlip
const Instr	kMovLeaveCCMask
const Instr	kMovLeaveCCPattern
const Instr	kMovwMask
const Instr	kMovwPattern
const Instr	kMovwLeaveCCFlip
const Instr	kCmpCmnMask
const Instr	kCmpCmnPattern
const Instr	kCmpCmnFlip
const Instr	kAddSubFlip
const Instr	kAndBicFlip
const VmovIndex	VmovIndexLo = { 0 }
const VmovIndex	VmovIndexHi = { 1 }
const int	kConstantPoolMarkerMask = 0xfff000f0
const int	kConstantPoolMarker = 0xe7f000f0
const int	kConstantPoolLengthMaxMask = 0xffff
const int	kCodeAgeJumpInstruction = 0xe51ff004
const int	kNumRegisters = 16
const int	kNumVFPSingleRegisters = 32
const int	kNumVFPDoubleRegisters = 32
const int	kNumVFPRegisters = kNumVFPSingleRegisters + kNumVFPDoubleRegisters
const int	kPCRegister = 15
const int	kNoRegister = -1
const uint32_t	kStopCodeMask = kStopCode - 1
const uint32_t	kMaxStopCode = kStopCode - 1
const int32_t	kDefaultStopCode = -1
const uint32_t	kVFPExceptionMask = 0xf
const uint32_t	kVFPInvalidOpExceptionBit = 1 << 0
const uint32_t	kVFPOverflowExceptionBit = 1 << 2
const uint32_t	kVFPUnderflowExceptionBit = 1 << 3
const uint32_t	kVFPInexactExceptionBit = 1 << 4
const uint32_t	kVFPFlushToZeroMask = 1 << 24
const uint32_t	kVFPDefaultNaNModeControlBit = 1 << 25
const uint32_t	kVFPNConditionFlagBit = 1 << 31
const uint32_t	kVFPZConditionFlagBit = 1 << 30
const uint32_t	kVFPCConditionFlagBit = 1 << 29
const uint32_t	kVFPVConditionFlagBit = 1 << 28
const uint32_t	kVFPRoundingModeMask = 3 << 22
const Instr	kPopInstruction
const Instr	kPushRegPattern
const Instr	kPopRegPattern
const Instr	kVldrDPCMask
const Instr	kVldrDPCPattern
const Instr	kLdrRegFpOffsetPattern
const Instr	kStrRegFpOffsetPattern
const Instr	kLdrRegFpNegOffsetPattern
const Instr	kStrRegFpNegOffsetPattern
const Instr	kLdrStrInstrTypeMask
const Instr	kLdrStrInstrArgumentMask
const Instr	kLdrStrOffsetMask
const int	kR9Available = 1
const int	kNumRegs = 16
const RegList	kJSCallerSaved
const int	kNumJSCallerSaved = 4
const RegList	kCalleeSaved
const RegList	kCallerSaved
const int	kNumCalleeSaved = 7 + kR9Available
const int	kNumDoubleCalleeSaved = 8
const int	kNumSafepointRegisters = 16
const RegList	kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved
const int	kNumSafepointSavedRegisters = kNumJSCallerSaved + kNumCalleeSaved
const Register	cp = { kRegister_r7_Code }
const Register	pp = { kRegister_r8_Code }
const Register	kRootRegister = { kRegister_r10_Code }
const int	kSmiShift = kSmiTagSize + kSmiShiftSize
const uint64_t	kSmiShiftMask = (1UL << kSmiShift) - 1
const unsigned	kInstructionSize = 4
const unsigned	kInstructionSizeLog2 = 2
const unsigned	kLiteralEntrySize = 4
const unsigned	kLiteralEntrySizeLog2 = 2
const unsigned	kMaxLoadLiteralRange = 1 * MB
const unsigned	kNumberOfRegisters = 32
const unsigned	kNumberOfFPRegisters = 32
const int	kNumberOfCalleeSavedRegisters = 11
const int	kFirstCalleeSavedRegisterIndex = 19
const int	kNumberOfCalleeSavedFPRegisters = 8
const int	kFirstCalleeSavedFPRegisterIndex = 8
const unsigned	kJSCalleeSavedRegList = 0x03f80000
const unsigned	kWRegSizeInBits = 32
const unsigned	kWRegSizeInBitsLog2 = 5
const unsigned	kWRegSize = kWRegSizeInBits >> 3
const unsigned	kWRegSizeLog2 = kWRegSizeInBitsLog2 - 3
const unsigned	kXRegSizeInBits = 64
const unsigned	kXRegSizeInBitsLog2 = 6
const unsigned	kXRegSize = kXRegSizeInBits >> 3
const unsigned	kXRegSizeLog2 = kXRegSizeInBitsLog2 - 3
const unsigned	kSRegSizeInBits = 32
const unsigned	kSRegSizeInBitsLog2 = 5
const unsigned	kSRegSize = kSRegSizeInBits >> 3
const unsigned	kSRegSizeLog2 = kSRegSizeInBitsLog2 - 3
const unsigned	kDRegSizeInBits = 64
const unsigned	kDRegSizeInBitsLog2 = 6
const unsigned	kDRegSize = kDRegSizeInBits >> 3
const unsigned	kDRegSizeLog2 = kDRegSizeInBitsLog2 - 3
const int64_t	kWRegMask = 0x00000000ffffffffL
const int64_t	kXRegMask = 0xffffffffffffffffL
const int64_t	kSRegMask = 0x00000000ffffffffL
const int64_t	kDRegMask = 0xffffffffffffffffL
const int64_t	kDSignBit = 63
const int64_t	kDSignMask = 0x1L << kDSignBit
const int64_t	kSSignBit = 31
const int64_t	kSSignMask = 0x1L << kSSignBit
const int64_t	kXSignBit = 63
const int64_t	kXSignMask = 0x1L << kXSignBit
const int64_t	kWSignBit = 31
const int64_t	kWSignMask = 0x1L << kWSignBit
const int64_t	kDQuietNanBit = 51
const int64_t	kDQuietNanMask = 0x1L << kDQuietNanBit
const int64_t	kSQuietNanBit = 22
const int64_t	kSQuietNanMask = 0x1L << kSQuietNanBit
const int64_t	kByteMask = 0xffL
const int64_t	kHalfWordMask = 0xffffL
const int64_t	kWordMask = 0xffffffffL
const uint64_t	kXMaxUInt = 0xffffffffffffffffUL
const uint64_t	kWMaxUInt = 0xffffffffUL
const int64_t	kXMaxInt = 0x7fffffffffffffffL
const int64_t	kXMinInt = 0x8000000000000000L
const int32_t	kWMaxInt = 0x7fffffff
const int32_t	kWMinInt = 0x80000000
const unsigned	kFramePointerRegCode = 29
const unsigned	kLinkRegCode = 30
const unsigned	kZeroRegCode = 31
const unsigned	kJSSPCode = 28
const unsigned	kSPRegInternalCode = 63
const unsigned	kRegCodeMask = 0x1f
const unsigned	kByteSize = 8
const unsigned	kByteSizeInBytes = kByteSize >> 3
const unsigned	kHalfWordSize = 16
const unsigned	kHalfWordSizeLog2 = 4
const unsigned	kHalfWordSizeInBytes = kHalfWordSize >> 3
const unsigned	kHalfWordSizeInBytesLog2 = kHalfWordSizeLog2 - 3
const unsigned	kWordSize = 32
const unsigned	kWordSizeLog2 = 5
const unsigned	kWordSizeInBytes = kWordSize >> 3
const unsigned	kWordSizeInBytesLog2 = kWordSizeLog2 - 3
const unsigned	kDoubleWordSize = 64
const unsigned	kDoubleWordSizeInBytes = kDoubleWordSize >> 3
const unsigned	kQuadWordSize = 128
const unsigned	kQuadWordSizeInBytes = kQuadWordSize >> 3
const unsigned	kDoubleMantissaBits = 52
const unsigned	kDoubleExponentBits = 11
const unsigned	kFloatMantissaBits = 23
const unsigned	kFloatExponentBits = 8
const int	ImmPCRel_mask = ImmPCRelLo_mask | ImmPCRelHi_mask
const int	kSFOffset = 31
const int	kBitfieldNOffset = 22
const int	kHltBadCode = 0xbad
const Instr	kImmExceptionIsRedirectedCall = 0xca11
const Instr	kImmExceptionIsUnreachable = 0xdebf
const Instr	kImmExceptionIsPrintf = 0xdeb1
const unsigned	kPrintfTypeOffset = 1 * kInstructionSize
const unsigned	kPrintfLength = 2 * kInstructionSize
const Instr	kImmExceptionIsDebug = 0xdeb0
const unsigned	kDebugCodeOffset = 1 * kInstructionSize
const unsigned	kDebugParamsOffset = 2 * kInstructionSize
const unsigned	kDebugMessageOffset = 3 * kInstructionSize
const unsigned	kDebuggerTracingDirectivesMask = 3 << 6
const int	kCounterNameMaxLength = 256
const uint64_t	kDefaultInstrumentationSamplingPeriod = 1 << 22
const int	kTagBits = 2
const int	kTagMask = (1 << kTagBits) - 1
const int	kExtraTagBits = 4
const int	kLocatableTypeTagBits = 2
const int	kSmallDataBits = kBitsPerByte - kLocatableTypeTagBits
const int	kEmbeddedObjectTag = 0
const int	kCodeTargetTag = 1
const int	kLocatableTag = 2
const int	kDefaultTag = 3
const int	kPCJumpExtraTag = (1 << kExtraTagBits) - 1
const int	kSmallPCDeltaBits = kBitsPerByte - kTagBits
const int	kSmallPCDeltaMask = (1 << kSmallPCDeltaBits) - 1
const int	kVariableLengthPCJumpTopTag = 1
const int	kChunkBits = 7
const int	kChunkMask = (1 << kChunkBits) - 1
const int	kLastChunkTagBits = 1
const int	kLastChunkTagMask = 1
const int	kLastChunkTag = 1
const int	kDataJumpExtraTag = kPCJumpExtraTag - 1
const int	kCodeWithIdTag = 0
const int	kNonstatementPositionTag = 1
const int	kStatementPositionTag = 2
const int	kCommentTag = 3
const int	kPoolExtraTag = kPCJumpExtraTag - 2
const int	kConstPoolTag = 0
const int	kVeneerPoolTag = 1
struct AtomicOps_x86CPUFeatureStruct	AtomicOps_Internalx86CPUFeatures
const int	BYTECODE_MASK = 0xff
const unsigned int	MAX_FIRST_ARG = 0x7fffffu
const int	BYTECODE_SHIFT = 8
const bool	FLAG_enable_slow_asserts = false
const int	kMaxSignificantDigits = 772
const int	kDoubleToCStringMinBufferSize = 100
const int	kBase10MaximalLength = 17
const int	kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1
const int	kFastElementsKindCount
const int	kFastElementsKindPackedToHoley
const int	kFastDtoaMaximalLength = 17
	false
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths	true
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object	size
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array	shift
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter	NULL
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to	optimize
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function	info
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf	map
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available	ENABLE_VFP3_DEFAULT
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for	ENABLE_32DREGS_DEFAULT
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in	name
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag	Hello
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag	world
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp	serdes
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage	message
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including	flags
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with	prof
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8	log
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp	__v8_gc__
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof arm64_inst	csv
JSCallerSavedCodeData	caller_saved_code_data
const int	KB = 1024
const int	MB = KB * KB
const int	GB = KB * KB * KB
const int	kMaxInt = 0x7FFFFFFF
const int	kMinInt = -kMaxInt - 1
const int	kMaxInt8 = (1 << 7) - 1
const int	kMinInt8 = -(1 << 7)
const int	kMaxUInt8 = (1 << 8) - 1
const int	kMinUInt8 = 0
const int	kMaxInt16 = (1 << 15) - 1
const int	kMinInt16 = -(1 << 15)
const int	kMaxUInt16 = (1 << 16) - 1
const int	kMinUInt16 = 0
const uint32_t	kMaxUInt32 = 0xFFFFFFFFu
const int	kCharSize = sizeof(char)
const int	kShortSize = sizeof(short)
const int	kIntSize = sizeof(int)
const int	kInt32Size = sizeof(int32_t)
const int	kInt64Size = sizeof(int64_t)
const int	kDoubleSize = sizeof(double)
const int	kIntptrSize = sizeof(intptr_t)
const int	kPointerSize = sizeof(void*)
const int	kRegisterSize = kPointerSize
const int	kPCOnStackSize = kRegisterSize
const int	kFPOnStackSize = kRegisterSize
const int	kDoubleSizeLog2 = 3
const int	kPointerSizeLog2 = 2
const intptr_t	kIntptrSignBit = 0x80000000
const uintptr_t	kUintptrAllBitsSet = 0xFFFFFFFFu
const bool	kIs64BitArch = false
const int	kBitsPerByte = 8
const int	kBitsPerByteLog2 = 3
const int	kBitsPerPointer = kPointerSize * kBitsPerByte
const int	kBitsPerInt = kIntSize * kBitsPerByte
const uint32_t	kBinary32SignMask = 0x80000000u
const uint32_t	kBinary32ExponentMask = 0x7f800000u
const uint32_t	kBinary32MantissaMask = 0x007fffffu
const int	kBinary32ExponentBias = 127
const int	kBinary32MaxExponent = 0xFE
const int	kBinary32MinExponent = 0x01
const int	kBinary32MantissaBits = 23
const int	kBinary32ExponentShift = 23
const uint64_t	kQuietNaNMask = static_cast<uint64_t>(0xfff) << 51
const int	kOneByteSize = kCharSize
const int	kUC16Size = sizeof(uc16)
const int	kRegister_eax_Code = 0
const int	kRegister_ecx_Code = 1
const int	kRegister_edx_Code = 2
const int	kRegister_ebx_Code = 3
const int	kRegister_esp_Code = 4
const int	kRegister_ebp_Code = 5
const int	kRegister_esi_Code = 6
const int	kRegister_edi_Code = 7
const Register	eax = { kRegister_eax_Code }
const Register	ecx = { kRegister_ecx_Code }
const Register	edx = { kRegister_edx_Code }
const Register	ebx = { kRegister_ebx_Code }
const Register	esp = { kRegister_esp_Code }
const Register	ebp = { kRegister_ebp_Code }
const Register	esi = { kRegister_esi_Code }
const Register	edi = { kRegister_edi_Code }
const IntelDoubleRegister	double_register_0 = { 0 }
const IntelDoubleRegister	double_register_1 = { 1 }
const IntelDoubleRegister	double_register_2 = { 2 }
const IntelDoubleRegister	double_register_3 = { 3 }
const IntelDoubleRegister	double_register_4 = { 4 }
const IntelDoubleRegister	double_register_5 = { 5 }
const IntelDoubleRegister	double_register_6 = { 6 }
const IntelDoubleRegister	double_register_7 = { 7 }
const IntelDoubleRegister	no_double_reg = { -1 }
const int	kNoAlignmentPadding = 0
const int	kAlignmentPaddingPushed = 2
const int	kAlignmentZapValue = 0x12345678
const int	kMaxKeyedPolymorphism = 4
struct v8::internal::StaticInitializer	static_initializer
const int	kMaxLookaheadForBoyerMoore = 8
const int	kPatternTooShortForBoyerMoore = 2
int	kUninitializedRegExpNodePlaceHolder
char	kStartTable [kStartTableLines *kStartTableEntriesPerLine]
const FPURegister	no_freg = { -1 }
const FPURegister	f0 = { 0 }
const FPURegister	f1 = { 1 }
const FPURegister	f2 = { 2 }
const FPURegister	f3 = { 3 }
const FPURegister	f4 = { 4 }
const FPURegister	f5 = { 5 }
const FPURegister	f6 = { 6 }
const FPURegister	f7 = { 7 }
const FPURegister	f8 = { 8 }
const FPURegister	f9 = { 9 }
const FPURegister	f10 = { 10 }
const FPURegister	f11 = { 11 }
const FPURegister	f12 = { 12 }
const FPURegister	f13 = { 13 }
const FPURegister	f14 = { 14 }
const FPURegister	f15 = { 15 }
const FPURegister	f16 = { 16 }
const FPURegister	f17 = { 17 }
const FPURegister	f18 = { 18 }
const FPURegister	f19 = { 19 }
const FPURegister	f20 = { 20 }
const FPURegister	f21 = { 21 }
const FPURegister	f22 = { 22 }
const FPURegister	f23 = { 23 }
const FPURegister	f24 = { 24 }
const FPURegister	f25 = { 25 }
const FPURegister	f26 = { 26 }
const FPURegister	f27 = { 27 }
const FPURegister	f28 = { 28 }
const FPURegister	f29 = { 29 }
const FPURegister	f30 = { 30 }
const FPURegister	f31 = { 31 }
const FPUControlRegister	no_fpucreg = { kInvalidFPUControlRegister }
const FPUControlRegister	FCSR = { kFCSRRegister }
const int	kInvalidRegister = -1
const int	kNumSimuRegisters = 35
const int	kNumFPURegisters = 32
const int	kInvalidFPURegister = -1
const int	kFCSRRegister = 31
const int	kInvalidFPUControlRegister = -1
const uint32_t	kFPUInvalidResult = static_cast<uint32_t>(1 << 31) - 1
const uint32_t	kFCSRInexactFlagBit = 2
const uint32_t	kFCSRUnderflowFlagBit = 3
const uint32_t	kFCSROverflowFlagBit = 4
const uint32_t	kFCSRDivideByZeroFlagBit = 5
const uint32_t	kFCSRInvalidOpFlagBit = 6
const uint32_t	kFCSRInexactFlagMask = 1 << kFCSRInexactFlagBit
const uint32_t	kFCSRUnderflowFlagMask = 1 << kFCSRUnderflowFlagBit
const uint32_t	kFCSROverflowFlagMask = 1 << kFCSROverflowFlagBit
const uint32_t	kFCSRDivideByZeroFlagMask = 1 << kFCSRDivideByZeroFlagBit
const uint32_t	kFCSRInvalidOpFlagMask = 1 << kFCSRInvalidOpFlagBit
const uint32_t	kFCSRFlagMask
const uint32_t	kFCSRExceptionFlagMask = kFCSRFlagMask ^ kFCSRInexactFlagMask
const int32_t	kPrefHintLoad = 0
const int32_t	kPrefHintStore = 1
const int32_t	kPrefHintLoadStreamed = 4
const int32_t	kPrefHintStoreStreamed = 5
const int32_t	kPrefHintLoadRetained = 6
const int32_t	kPrefHintStoreRetained = 7
const int32_t	kPrefHintWritebackInvalidate = 25
const int32_t	kPrefHintPrepareForStore = 30
const uint32_t	kMaxWatchpointCode = 31
const int	kOpcodeShift = 26
const int	kOpcodeBits = 6
const int	kRsShift = 21
const int	kRsBits = 5
const int	kRtShift = 16
const int	kRtBits = 5
const int	kRdShift = 11
const int	kRdBits = 5
const int	kSaShift = 6
const int	kSaBits = 5
const int	kFunctionShift = 0
const int	kFunctionBits = 6
const int	kLuiShift = 16
const int	kImm16Shift = 0
const int	kImm16Bits = 16
const int	kImm26Shift = 0
const int	kImm26Bits = 26
const int	kImm28Shift = 0
const int	kImm28Bits = 28
const int	kImmFieldShift = 2
const int	kFrBits = 5
const int	kFrShift = 21
const int	kFsShift = 11
const int	kFsBits = 5
const int	kFtShift = 16
const int	kFtBits = 5
const int	kFdShift = 6
const int	kFdBits = 5
const int	kFCccShift = 8
const int	kFCccBits = 3
const int	kFBccShift = 18
const int	kFBccBits = 3
const int	kFBtrueShift = 16
const int	kFBtrueBits = 1
const int	kOpcodeMask = ((1 << kOpcodeBits) - 1) << kOpcodeShift
const int	kImm26Mask = ((1 << kImm26Bits) - 1) << kImm26Shift
const int	kImm28Mask = ((1 << kImm28Bits) - 1) << kImm28Shift
const int	kRsFieldMask = ((1 << kRsBits) - 1) << kRsShift
const int	kRtFieldMask = ((1 << kRtBits) - 1) << kRtShift
const int	kRdFieldMask = ((1 << kRdBits) - 1) << kRdShift
const int	kSaFieldMask = ((1 << kSaBits) - 1) << kSaShift
const int	kFunctionFieldMask = ((1 << kFunctionBits) - 1) << kFunctionShift
const int	kHiMask = 0xffff << 16
const int	kLoMask = 0xffff
const int	kSignMask = 0x80000000
const int	kJumpAddrMask = (1 << (kImm26Bits + kImmFieldShift)) - 1
const uint32_t	kFPURoundingModeMask = 3 << 0
const Instr	kPushInstruction
const Instr	kLwRegFpOffsetPattern
const Instr	kSwRegFpOffsetPattern
const Instr	kLwRegFpNegOffsetPattern
const Instr	kSwRegFpNegOffsetPattern
const Instr	kRtMask
const Instr	kLwSwInstrTypeMask
const Instr	kLwSwInstrArgumentMask
const Instr	kLwSwOffsetMask
const Instr	rtCallRedirInstr = SPECIAL | BREAK | call_rt_redirected << 6
const Instr	nopInstr = 0
const int	kCArgSlotCount = 4
const int	kCArgsSlotsSize = kCArgSlotCount * Instruction::kInstrSize
const int	kJSArgsSlotsSize = 0 * Instruction::kInstrSize
const int	kBArgsSlotsSize = 0 * Instruction::kInstrSize
const int	kBranchReturnOffset = 2 * Instruction::kInstrSize
const RegList	kCalleeSavedFPU
const int	kNumCalleeSavedFPU = 6
const RegList	kCallerSavedFPU
const int	kUndefIndex = -1
const int	kSafepointRegisterStackIndexMap [kNumRegs]
	first_heap_ptr_index
	serialized_data
	ByteArray
kSerializedDataOffset	prototype_template
kSerializedDataOffset	Object
kSerializedDataOffset kPrototypeTemplateOffset	indexed_property_handler
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset	instance_call_handler
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset	internal_field_count
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset	dependent_code
kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset	DependentCode
	instance_class_name
kInstanceClassNameOffset	flag
kInstanceClassNameOffset	needs_access_check
kInstanceClassNameOffset kNeedsAccessCheckBit	remove_prototype
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit	start_position_and_type
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit	is_expression
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit	compiler_hints
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit	allows_lazy_compilation
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation	uses_arguments
kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments	formal_parameter_count
	name_should_print_as_anonymous
const int	kVariableSizeSentinel = 0
const int	kStubMajorKeyBits = 7
const int	kStubMinorKeyBits = kBitsPerInt - kSmiTagSize - kStubMajorKeyBits
const uint32_t	kIsNotStringMask = 0x80
const uint32_t	kStringTag = 0x0
const uint32_t	kNotStringTag = 0x80
const uint32_t	kIsNotInternalizedMask = 0x40
const uint32_t	kNotInternalizedTag = 0x40
const uint32_t	kInternalizedTag = 0x0
const uint32_t	kStringEncodingMask = 0x4
const uint32_t	kTwoByteStringTag = 0x0
const uint32_t	kOneByteStringTag = 0x4
const uint32_t	kStringRepresentationMask = 0x03
const uint32_t	kIsIndirectStringMask = 0x1
const uint32_t	kIsIndirectStringTag = 0x1
const uint32_t	kSlicedNotConsMask = kSlicedStringTag & ~kConsStringTag
const uint32_t	kOneByteDataHintMask = 0x08
const uint32_t	kOneByteDataHintTag = 0x08
const uint32_t	kShortExternalStringMask = 0x10
const uint32_t	kShortExternalStringTag = 0x10
const uint32_t	kShortcutTypeMask
const uint32_t	kShortcutTypeTag = kConsStringTag | kNotInternalizedTag
const int	kExternalArrayTypeCount
const int	kFailureTypeTagSize = 2
const int	kFailureTypeTagMask = (1 << kFailureTypeTagSize) - 1
const int	kStringBuilderConcatHelperLengthBits = 11
const int	kStringBuilderConcatHelperPositionBits = 19
const int	kTypeCodeCount = LAZY_DEOPTIMIZATION + 1
const int	kFirstTypeCode = UNCLASSIFIED
const int	kReferenceIdBits = 16
const int	kReferenceIdMask = (1 << kReferenceIdBits) - 1
const int	kReferenceTypeShift = kReferenceIdBits
const int	kDebugRegisterBits = 4
const int	kDebugIdShift = kDebugRegisterBits
const int	kDeoptTableSerializeEntryCount = 12
const intptr_t	kSmiSignMask = kIntptrSignBit
const int	kObjectAlignmentBits = kPointerSizeLog2
const intptr_t	kObjectAlignment = 1 << kObjectAlignmentBits
const intptr_t	kObjectAlignmentMask = kObjectAlignment - 1
const intptr_t	kPointerAlignment = (1 << kPointerSizeLog2)
const intptr_t	kPointerAlignmentMask = kPointerAlignment - 1
const intptr_t	kDoubleAlignment = 8
const intptr_t	kDoubleAlignmentMask = kDoubleAlignment - 1
const int	kCodeAlignmentBits = 5
const intptr_t	kCodeAlignment = 1 << kCodeAlignmentBits
const intptr_t	kCodeAlignmentMask = kCodeAlignment - 1
const int	kFailureTag = 3
const int	kFailureTagSize = 2
const intptr_t	kFailureTagMask = (1 << kFailureTagSize) - 1
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
const int	kCodeZapValue = 0xbadc0de
const int	kPageSizeBits = 20
const uint32_t	kQuietNaNHighBitsMask = 0xfff << (51 - 32)
const int	kSpaceTagSize = 3
const int	kSpaceTagMask = (1 << kSpaceTagSize) - 1
const uint32_t	kHoleNanUpper32 = 0x7FFFFFFF
const uint32_t	kHoleNanLower32 = 0xFFFFFFFF
const uint32_t	kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000
const uint64_t	kHoleNanInt64
const uint64_t	kLastNonNaNInt64
const int	kRegister_rax_Code = 0
const int	kRegister_rcx_Code = 1
const int	kRegister_rdx_Code = 2
const int	kRegister_rbx_Code = 3
const int	kRegister_rsp_Code = 4
const int	kRegister_rbp_Code = 5
const int	kRegister_rsi_Code = 6
const int	kRegister_rdi_Code = 7
const int	kRegister_r11_Code = 11
const int	kRegister_r12_Code = 12
const int	kRegister_r13_Code = 13
const int	kRegister_r14_Code = 14
const int	kRegister_r15_Code = 15
const Register	rax = { kRegister_rax_Code }
const Register	rcx = { kRegister_rcx_Code }
const Register	rdx = { kRegister_rdx_Code }
const Register	rbx = { kRegister_rbx_Code }
const Register	rsp = { kRegister_rsp_Code }
const Register	rbp = { kRegister_rbp_Code }
const Register	rsi = { kRegister_rsi_Code }
const Register	rdi = { kRegister_rdi_Code }
const Register	r11 = { kRegister_r11_Code }
const Register	r12 = { kRegister_r12_Code }
const Register	r13 = { kRegister_r13_Code }
const Register	r14 = { kRegister_r14_Code }
const Register	r15 = { kRegister_r15_Code }
const Register	arg_reg_1 = { kRegister_rdi_Code }
const Register	arg_reg_2 = { kRegister_rsi_Code }
const Register	arg_reg_3 = { kRegister_rdx_Code }
const Register	arg_reg_4 = { kRegister_rcx_Code }
const XMMRegister	xmm0 = { 0 }
const XMMRegister	xmm1 = { 1 }
const XMMRegister	xmm2 = { 2 }
const XMMRegister	xmm3 = { 3 }
const XMMRegister	xmm4 = { 4 }
const XMMRegister	xmm5 = { 5 }
const XMMRegister	xmm6 = { 6 }
const XMMRegister	xmm7 = { 7 }
const XMMRegister	xmm8 = { 8 }
const XMMRegister	xmm9 = { 9 }
const XMMRegister	xmm10 = { 10 }
const XMMRegister	xmm11 = { 11 }
const XMMRegister	xmm12 = { 12 }
const XMMRegister	xmm13 = { 13 }
const XMMRegister	xmm14 = { 14 }
const XMMRegister	xmm15 = { 15 }
const Register	kScratchRegister = { 10 }
const Register	kSmiConstantRegister = { 12 }
const int	kSmiConstantRegisterValue = 1
const int	kRootRegisterBias = 128

Typedef Documentation

typedef char __tsan_atomic128

Definition at line 67 of file atomicops_internals_tsan.h.

typedef short __tsan_atomic16

Definition at line 58 of file atomicops_internals_tsan.h.

typedef int __tsan_atomic32

Definition at line 59 of file atomicops_internals_tsan.h.

typedef long __tsan_atomic64

Definition at line 60 of file atomicops_internals_tsan.h.

typedef char __tsan_atomic8

Definition at line 57 of file atomicops_internals_tsan.h.

typedef DWORD64 AddrBase

Definition at line 1103 of file platform-win32.cc.

typedef byte* Address

Definition at line 186 of file globals.h.

typedef PerIsolateAssertScopeDebugOnly<ALLOCATION_FAILURE_ASSERT, true> AllowAllocationFailure

Definition at line 269 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<CODE_DEPENDENCY_CHANGE_ASSERT, true> AllowCodeDependencyChange

Definition at line 242 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<DEFERRED_HANDLE_DEREFERENCE_ASSERT, true> AllowDeferredHandleDereference

Definition at line 234 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<HANDLE_ALLOCATION_ASSERT, true> AllowHandleAllocation

Definition at line 210 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<HANDLE_DEREFERENCE_ASSERT, true> AllowHandleDereference

Definition at line 226 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<HEAP_ALLOCATION_ASSERT, true> AllowHeapAllocation

Definition at line 218 of file assert-scope.h.

typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, true> AllowJavascriptExecution

Definition at line 253 of file assert-scope.h.

typedef int(* arm64_regexp_matcher)(String *input, int64_t start_offset, const byte *input_start, const byte *input_end, int *output, int64_t output_size, Address stack_base, int64_t direct_call, void *return_address, Isolate *isolate)

Definition at line 61 of file simulator-arm64.h.

typedef int(* arm_regexp_matcher)(String *, int, const byte *, const byte *, void *, int *, int, Address, int, Isolate *)

Definition at line 51 of file simulator-arm.h.

typedef int32_t Atomic32

Definition at line 66 of file atomicops.h.

typedef intptr_t AtomicWord

Definition at line 79 of file atomicops.h.

typedef IN HANDLE IN PSTR IN PSTR IN DWORD64 BaseOfDll

Definition at line 1075 of file platform-win32.cc.

typedef BoundsImpl<ZoneTypeConfig> Bounds

Definition at line 644 of file types.h.

typedef uint8_t byte

Definition at line 185 of file globals.h.

typedef unibrow::Mapping<unibrow::Ecma262Canonicalize> Canonicalize

Definition at line 44 of file interpreter-irregexp.cc.

typedef List<Handle<Code> > CodeHandleList

Definition at line 220 of file list.h.

typedef List<Code*> CodeList

Definition at line 217 of file list.h.

typedef bool(* ConstraintCallback)(Address new_addr, Address old_addr)

Definition at line 254 of file v8globals.h.

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID ContextRecord

Definition at line 1082 of file platform-win32.cc.

typedef List<HeapObject*> DebugObjectCache

Definition at line 345 of file isolate.h.

typedef PerIsolateAssertScopeDebugOnly<ALLOCATION_FAILURE_ASSERT, false> DisallowAllocationFailure

Definition at line 265 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<CODE_DEPENDENCY_CHANGE_ASSERT, false> DisallowCodeDependencyChange

Definition at line 238 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<DEFERRED_HANDLE_DEREFERENCE_ASSERT, false> DisallowDeferredHandleDereference

Definition at line 230 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<HANDLE_ALLOCATION_ASSERT, false> DisallowHandleAllocation

Definition at line 206 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<HANDLE_DEREFERENCE_ASSERT, false> DisallowHandleDereference

Definition at line 222 of file assert-scope.h.

typedef PerThreadAssertScopeDebugOnly<HEAP_ALLOCATION_ASSERT, false> DisallowHeapAllocation

Definition at line 214 of file assert-scope.h.

typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, false> DisallowJavascriptExecution

Definition at line 249 of file assert-scope.h.

typedef XMMRegister DoubleRegister

Definition at line 319 of file assembler-arm.h.

typedef bool EmitCharacterFunction(Isolate *isolate, RegExpCompiler *compiler, uc16 c, Label *on_failure, int cp_offset, bool check, bool preloaded)

Definition at line 1731 of file jsregexp.cc.

typedef NativesCollection<EXPERIMENTAL> ExperimentalNatives

Definition at line 63 of file natives.h.

typedef void* ExternalReferenceRedirectorPointer()

Definition at line 95 of file isolate.h.

typedef StringTableCleaner<true> ExternalStringTableCleaner

Definition at line 1934 of file mark-compact.cc.

typedef String*(* ExternalStringTableUpdaterCallback)(Heap *heap, Object **pointer)

Definition at line 388 of file heap.h.

typedef int ExtraICState

Definition at line 310 of file objects.h.

typedef IN PSTR IN BOOL fInvadeProcess

Definition at line 1065 of file platform-win32.cc.

typedef FPURegister FloatRegister

Definition at line 273 of file assembler-mips.h.

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine

Definition at line 1082 of file platform-win32.cc.

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine

Definition at line 1082 of file platform-win32.cc.

typedef EnumSet<GVNFlag, int32_t> GVNFlagSet

Definition at line 548 of file hydrogen-instructions.h.

typedef TemplateHashMapImpl<FreeStoreAllocationPolicy> HashMap

Definition at line 113 of file hashmap.h.

typedef int(* HeapObjectCallback)(HeapObject *obj)

Definition at line 248 of file v8globals.h.

typedef void* HeapThing

Definition at line 292 of file heap-snapshot-generator.h.

typedef TypeImpl< HeapTypeConfig > HeapType

Definition at line 212 of file list.h.

typedef IN HANDLE hFile

Definition at line 1075 of file platform-win32.cc.

typedef HANDLE hProcess

Definition at line 1082 of file platform-win32.cc.

typedef HANDLE HANDLE hThread

Definition at line 1082 of file platform-win32.cc.

typedef IN HANDLE IN PSTR ImageName

Definition at line 1075 of file platform-win32.cc.

typedef void(* InlineCacheCallback)(Code *code, Address ic)

Definition at line 259 of file v8globals.h.

typedef int32_t Instr

Definition at line 147 of file constants-arm.h.

typedef StringTableCleaner<false> InternalizedStringTableCleaner

Definition at line 1933 of file mark-compact.cc.

typedef std::vector<int, ZoneIntAllocator> IntVector

Definition at line 40 of file zone-containers.h.

typedef IntVector::iterator IntVectorIter

Definition at line 41 of file zone-containers.h.

typedef IntVector::reverse_iterator IntVectorRIter

Definition at line 42 of file zone-containers.h.

typedef bool(* IsAliveFunction)(HeapObject *obj, int *size, int *offset)

Definition at line 40 of file mark-compact.h.

typedef Object * JSCallerSavedBuffer

Definition at line 55 of file frames-arm.h.

typedef LazyStaticInstance<ConditionVariable, DefaultConstructTrait<ConditionVariable>, ThreadSafeInitOnceTrait>::type LazyConditionVariable

Definition at line 134 of file condition-variable.h.

typedef LazyStaticInstance<Mutex, DefaultConstructTrait<Mutex>, ThreadSafeInitOnceTrait>::type LazyMutex

Definition at line 128 of file mutex.h.

typedef LazyStaticInstance<RecursiveMutex, DefaultConstructTrait<RecursiveMutex>, ThreadSafeInitOnceTrait>::type LazyRecursiveMutex

Definition at line 209 of file mutex.h.

typedef IN DWORD64 OUT PDWORD OUT PIMAGEHLP_LINE64 Line64

Definition at line 1097 of file platform-win32.cc.

typedef LPMODULEENTRY32W lpme

Definition at line 1113 of file platform-win32.cc.

typedef List<Handle<Map> > MapHandleList

Definition at line 218 of file list.h.

typedef List<Map*> MapList

Definition at line 215 of file list.h.

typedef UniqueSet<Map>* MapSet

Definition at line 47 of file hydrogen-check-elimination.cc.

typedef Operand MemOperand

Definition at line 40 of file macro-assembler-ia32.h.

typedef int(* mips_regexp_matcher)(String *, int, const byte *, const byte *, void *, int *, int, Address, int, Isolate *)

Definition at line 52 of file simulator-mips.h.

typedef IN HANDLE IN PSTR IN PSTR ModuleName

Definition at line 1075 of file platform-win32.cc.

typedef NativesCollection<CORE> Natives

Definition at line 62 of file natives.h.

typedef bool(* NativeSourceCallback)(Vector< const char > name, Vector< const char > source, int index)

Definition at line 34 of file natives.h.

typedef void(* NoArgFunction)()

Definition at line 95 of file once.h.

typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, true> NoThrowOnJavascriptExecution

Definition at line 261 of file assert-scope.h.

typedef uint64_t ObjectPair

Definition at line 9288 of file runtime.cc.

typedef void(* ObjectSlotCallback)(HeapObject **from, HeapObject *to)

Definition at line 44 of file store-buffer.h.

typedef AtomicWord OnceType

Definition at line 83 of file once.h.

typedef IN DWORD64 OUT PDWORD pdwDisplacement

Definition at line 1092 of file platform-win32.cc.

typedef SmiTagging<kApiPointerSize> PlatformSmiTagging

Definition at line 5538 of file v8.h.

typedef void(* PointerArgFunction)(void *arg)

Definition at line 96 of file once.h.

typedef QwNeonRegister QuadRegister

Definition at line 391 of file assembler-arm.h.

typedef IN DWORD64 qwAddr

Definition at line 1092 of file platform-win32.cc.

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine

Definition at line 1082 of file platform-win32.cc.

typedef int(* regexp_matcher)(String *, int, const byte *, const byte *, int *, int, Address, int, Isolate *)

Definition at line 42 of file simulator-ia32.h.

typedef void(StoreBuffer::* RegionCallback)(Address start, Address end, ObjectSlotCallback slot_callback, bool clear_maps)

Definition at line 46 of file store-buffer.h.

typedef uint32_t RegList

Definition at line 41 of file frames.h.

typedef void(* ScavengingCallback)(Map *map, HeapObject **slot, HeapObject *object)

Definition at line 509 of file heap.h.

typedef OUT PSTR SearchPath

Definition at line 1071 of file platform-win32.cc.

typedef OUT PSTR IN DWORD SearchPathLength

Definition at line 1071 of file platform-win32.cc.

typedef SimpleStringResource<char, v8::String::ExternalAsciiStringResource> SimpleAsciiStringResource

Definition at line 54 of file externalize-string-extension.cc.

typedef SimpleStringResource<uc16, v8::String::ExternalStringResource> SimpleTwoByteStringResource

Definition at line 56 of file externalize-string-extension.cc.

typedef IN HANDLE IN PSTR IN PSTR IN DWORD64 IN DWORD SizeOfDll

Definition at line 1075 of file platform-win32.cc.

typedef uint32_t SRegisterFieldMask

Definition at line 279 of file constants-arm.h.

typedef HANDLE HANDLE LPSTACKFRAME64 StackFrame

Definition at line 1082 of file platform-win32.cc.

typedef void(* StoreBufferCallback)(Heap *heap, MemoryChunk *page, StoreBufferEvent event)

Definition at line 308 of file v8globals.h.

typedef BitField<int, 0, kStringBuilderConcatHelperLengthBits> StringBuilderSubstringLength

Definition at line 3410 of file runtime.cc.

typedef BitField<int, kStringBuilderConcatHelperLengthBits, kStringBuilderConcatHelperPositionBits> StringBuilderSubstringPosition

Definition at line 3414 of file runtime.cc.

typedef IN DWORD64 OUT PDWORD64 OUT PIMAGEHLP_SYMBOL64 Symbol

Definition at line 1092 of file platform-win32.cc.

typedef DWORD th32ProcessID

Definition at line 1111 of file platform-win32.cc.

typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, false> ThrowOnJavascriptExecution

Definition at line 257 of file assert-scope.h.

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64 PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress

Definition at line 1082 of file platform-win32.cc.

typedef TypeImpl< ZoneTypeConfig > Type

Definition at line 62 of file property-details.h.

typedef List<Handle<HeapType> > TypeHandleList

Definition at line 219 of file list.h.

typedef uint16_t uc16

Definition at line 309 of file globals.h.

typedef int32_t uc32

Definition at line 310 of file globals.h.

typedef double(* UnaryMathFunction)(double x)

Definition at line 119 of file codegen.h.

typedef IN PSTR UserSearchPath

Definition at line 1065 of file platform-win32.cc.

typedef bool(* WeakSlotCallback)(Object **pointer)

Definition at line 169 of file v8globals.h.

typedef bool(* WeakSlotCallbackWithHeap)(Heap *heap, Object **pointer)

Definition at line 171 of file v8globals.h.

typedef TemplateHashMapImpl<ZoneAllocationPolicy> ZoneHashMap

Definition at line 267 of file zone.h.

typedef zone_allocator<int> ZoneIntAllocator

Definition at line 39 of file zone-containers.h.

typedef ZoneList< Handle< Object > > ZoneObjectList

Definition at line 162 of file ast.h.

typedef ZoneList<Handle<String> > ZoneStringList

Definition at line 161 of file ast.h.

Enumeration Type Documentation

anonymous enum

Enumerator
H
S6
L
S
W
A
B
N
U
P
I
B4
B5
B6
B7
B8
B9
B12
B16
B18
B19
B20
B21
B22
B23
B24
B25
B26
B27
B28
kCondMask
kALUMask
kRdMask
kCoprocessorMask
kOpCodeMask
kImm24Mask
kImm16Mask
kImm8Mask
kOff12Mask
kOff8Mask

Definition at line 186 of file constants-arm.h.

anonymous enum

Enumerator
ONCE_STATE_UNINITIALIZED
ONCE_STATE_EXECUTING_FUNCTION
ONCE_STATE_DONE

Definition at line 89 of file once.h.

enum __tsan_memory_order

Enumerator
__tsan_memory_order_relaxed
__tsan_memory_order_consume
__tsan_memory_order_acquire
__tsan_memory_order_release
__tsan_memory_order_acq_rel
__tsan_memory_order_seq_cst

Definition at line 71 of file atomicops_internals_tsan.h.

enum AccessCheckResult

Enumerator
ACCESS_FORBIDDEN
ACCESS_ALLOWED
ACCESS_ABSENT

Definition at line 1855 of file runtime.cc.

enum AccessorComponent

Enumerator
ACCESSOR_GETTER
ACCESSOR_SETTER

Definition at line 2015 of file objects.h.

enum AccessorDescriptorType

Enumerator
kDescriptorBitmaskCompare
kDescriptorPointerCompare
kDescriptorPrimitiveValue
kDescriptorObjectDereference
kDescriptorPointerDereference
kDescriptorPointerShift
kDescriptorReturnObject

Definition at line 10156 of file objects.h.

enum AddrMode

Enumerator
Offset
PreIndex
PostIndex
NegOffset
NegPreIndex
NegPostIndex
Offset
PreIndex
PostIndex

Definition at line 95 of file instructions-arm64.h.

enum AddrMode

Enumerator
Offset
PreIndex
PostIndex
NegOffset
NegPreIndex
NegPostIndex
Offset
PreIndex
PostIndex

Definition at line 283 of file constants-arm.h.

enum AddSubExtendedOp

Enumerator
AddSubExtendedFixed
AddSubExtendedFMask
AddSubExtendedMask

Definition at line 486 of file constants-arm64.h.

enum AddSubImmediateOp

Enumerator
AddSubImmediateFixed
AddSubImmediateFMask
AddSubImmediateMask

Definition at line 464 of file constants-arm64.h.

enum AddSubOp

Enumerator
AddSubOpMask
AddSubSetFlagsBit
ADD
ADDS
SUB
SUBS

Definition at line 449 of file constants-arm64.h.

enum AddSubShiftedOp

Enumerator
AddSubShiftedFixed
AddSubShiftedFMask
AddSubShiftedMask

Definition at line 475 of file constants-arm64.h.

enum AddSubWithCarryOp

Enumerator
AddSubWithCarryFixed
AddSubWithCarryFMask
AddSubWithCarryMask
ADC_w
ADC_x
ADC
ADCS_w
ADCS_x
SBC_w
SBC_x
SBC
SBCS_w
SBCS_x

Definition at line 498 of file constants-arm64.h.

enum AllocationSiteMode

Enumerator
DONT_TRACK_ALLOCATION_SITE
TRACK_ALLOCATION_SITE
LAST_ALLOCATION_SITE_MODE

Definition at line 8251 of file objects.h.

enum AllocationSiteOverrideMode

Enumerator
DONT_OVERRIDE
DISABLE_ALLOCATION_SITES
LAST_ALLOCATION_SITE_OVERRIDE_MODE

Definition at line 759 of file code-stubs.h.

enum AllocationSpace

Enumerator
NEW_SPACE
OLD_POINTER_SPACE
OLD_DATA_SPACE
CODE_SPACE
MAP_SPACE
CELL_SPACE
PROPERTY_CELL_SPACE
LO_SPACE
FIRST_SPACE
LAST_SPACE
FIRST_PAGED_SPACE
LAST_PAGED_SPACE

Definition at line 178 of file v8globals.h.

enum AllowNullsFlag

Enumerator
ALLOW_NULLS
DISALLOW_NULLS

Definition at line 8494 of file objects.h.

enum ArgumentsAllowedFlag

Enumerator
ARGUMENTS_NOT_ALLOWED
ARGUMENTS_ALLOWED

Definition at line 764 of file hydrogen.h.

enum ArrayHasHoles

Enumerator
kArrayCantHaveHoles
kArrayCanHaveHoles

Definition at line 122 of file macro-assembler-arm64.h.

enum ArrayStorageAllocationMode

Enumerator
DONT_INITIALIZE_ARRAY_ELEMENTS
INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE

Definition at line 554 of file heap.h.

enum AstPropertiesFlag

Enumerator
kDontInline
kDontSelfOptimize
kDontSoftInline
kDontCache

Definition at line 173 of file ast.h.

enum BailoutReason

Enumerator
kLastErrorMessage

Definition at line 1424 of file objects.h.

enum BarrierDomain

Enumerator
OuterShareable
NonShareable
InnerShareable
FullSystem

Definition at line 380 of file constants-arm64.h.

enum BarrierType

Enumerator
BarrierOther
BarrierReads
BarrierWrites
BarrierAll

Definition at line 387 of file constants-arm64.h.

enum BignumDtoaMode

Enumerator
BIGNUM_DTOA_SHORTEST
BIGNUM_DTOA_FIXED
BIGNUM_DTOA_PRECISION

Definition at line 34 of file bignum-dtoa.h.

enum BindingFlags

Enumerator
MUTABLE_IS_INITIALIZED
MUTABLE_CHECK_INITIALIZED
IMMUTABLE_IS_INITIALIZED
IMMUTABLE_CHECK_INITIALIZED
IMMUTABLE_IS_INITIALIZED_HARMONY
IMMUTABLE_CHECK_INITIALIZED_HARMONY
MISSING_BINDING

Definition at line 79 of file contexts.h.

enum BitfieldOp

Enumerator
BitfieldFixed
BitfieldFMask
BitfieldMask
SBFM_w
SBFM_x
SBFM
BFM_w
BFM_x
BFM
UBFM_w
UBFM_x
UBFM

Definition at line 593 of file constants-arm64.h.

enum BlockAddrMode

Enumerator
da
ia
db
ib
da_w
ia_w
db_w
ib_w
da_x
ia_x
db_x
ib_x
kBlockAddrModeMask

Definition at line 295 of file constants-arm.h.

enum BranchDelaySlot

Enumerator
USE_DELAY_SLOT
PROTECT

Definition at line 79 of file macro-assembler-mips.h.

enum BranchType

Enumerator
integer_eq
integer_ne
integer_hs
integer_lo
integer_mi
integer_pl
integer_vs
integer_vc
integer_hi
integer_ls
integer_ge
integer_lt
integer_gt
integer_le
integer_al
integer_nv
always
never
reg_zero
reg_not_zero
reg_bit_clear
reg_bit_set
kBranchTypeFirstCondition
kBranchTypeLastCondition
kBranchTypeFirstUsingReg
kBranchTypeFirstUsingBit

Definition at line 67 of file macro-assembler-arm64.h.

enum BuiltinExtraArguments

Enumerator
NO_EXTRA_ARGUMENTS
NEEDS_CALLED_FUNCTION

Definition at line 35 of file builtins.h.

enum BuiltinFunctionId

Enumerator
kArrayCode
kMathPowHalf
kMathClz32

Definition at line 6680 of file objects.h.

enum CachedDataMode

Enumerator
NO_CACHED_DATA
CONSUME_CACHED_DATA
PRODUCE_CACHED_DATA

Definition at line 48 of file compiler.h.

enum CallFunctionFlags

Enumerator
NO_CALL_FUNCTION_FLAGS
RECORD_CALL_TARGET
CALL_AS_METHOD
WRAP_AND_CALL

Definition at line 283 of file v8globals.h.

enum CheckForInexactConversion

Enumerator
kCheckForInexactConversion
kDontCheckForInexactConversion
kCheckForInexactConversion
kDontCheckForInexactConversion

Definition at line 414 of file constants-arm.h.

enum CheckForInexactConversion

Enumerator
kCheckForInexactConversion
kDontCheckForInexactConversion
kCheckForInexactConversion
kDontCheckForInexactConversion

Definition at line 564 of file constants-mips.h.

enum ClearExceptionFlag

Enumerator
KEEP_EXCEPTION
CLEAR_EXCEPTION

Definition at line 555 of file v8globals.h.

enum CompareBranchOp

Enumerator
CompareBranchFixed
CompareBranchFMask
CompareBranchMask
CBZ_w
CBZ_x
CBZ
CBNZ_w
CBNZ_x
CBNZ

Definition at line 639 of file constants-arm64.h.

enum CompareResult

Enumerator
LESS
EQUAL
GREATER
NOT_EQUAL

Definition at line 882 of file objects.h.

enum ComputablePhase

Enumerator
DURING_PARSE
AFTER_SCOPING

Definition at line 38 of file feedback-slots.h.

enum Condition

Enumerator
kNoCondition
eq
ne
cs
cc
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
kSpecialCondition
kNumberOfConditions
hs
lo
eq
ne
hs
lo
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
nv
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
carry
not_carry
zero
not_zero
sign
not_sign
kNoCondition
overflow
no_overflow
Uless
Ugreater_equal
equal
not_equal
Uless_equal
Ugreater
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
ueq
nue
cc_always
carry
not_carry
zero
eq
not_zero
ne
nz
sign
not_sign
mi
pl
hi
ls
ge
lt
gt
le
hs
lo
al
cc_default
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
always
never
carry
not_carry
zero
not_zero
sign
not_sign
last_condition

Definition at line 81 of file constants-arm.h.

enum Condition

Enumerator
kNoCondition
eq
ne
cs
cc
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
kSpecialCondition
kNumberOfConditions
hs
lo
eq
ne
hs
lo
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
nv
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
carry
not_carry
zero
not_zero
sign
not_sign
kNoCondition
overflow
no_overflow
Uless
Ugreater_equal
equal
not_equal
Uless_equal
Ugreater
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
ueq
nue
cc_always
carry
not_carry
zero
eq
not_zero
ne
nz
sign
not_sign
mi
pl
hi
ls
ge
lt
gt
le
hs
lo
al
cc_default
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
always
never
carry
not_carry
zero
not_zero
sign
not_sign
last_condition

Definition at line 262 of file constants-arm64.h.

enum Condition

Enumerator
kNoCondition
eq
ne
cs
cc
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
kSpecialCondition
kNumberOfConditions
hs
lo
eq
ne
hs
lo
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
nv
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
carry
not_carry
zero
not_zero
sign
not_sign
kNoCondition
overflow
no_overflow
Uless
Ugreater_equal
equal
not_equal
Uless_equal
Ugreater
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
ueq
nue
cc_always
carry
not_carry
zero
eq
not_zero
ne
nz
sign
not_sign
mi
pl
hi
ls
ge
lt
gt
le
hs
lo
al
cc_default
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
always
never
carry
not_carry
zero
not_zero
sign
not_sign
last_condition

Definition at line 273 of file assembler-ia32.h.

enum Condition

Enumerator
kNoCondition
eq
ne
cs
cc
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
kSpecialCondition
kNumberOfConditions
hs
lo
eq
ne
hs
lo
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
nv
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
carry
not_carry
zero
not_zero
sign
not_sign
kNoCondition
overflow
no_overflow
Uless
Ugreater_equal
equal
not_equal
Uless_equal
Ugreater
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
ueq
nue
cc_always
carry
not_carry
zero
eq
not_zero
ne
nz
sign
not_sign
mi
pl
hi
ls
ge
lt
gt
le
hs
lo
al
cc_default
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
always
never
carry
not_carry
zero
not_zero
sign
not_sign
last_condition

Definition at line 284 of file assembler-x64.h.

enum Condition

Enumerator
kNoCondition
eq
ne
cs
cc
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
kSpecialCondition
kNumberOfConditions
hs
lo
eq
ne
hs
lo
mi
pl
vs
vc
hi
ls
ge
lt
gt
le
al
nv
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
carry
not_carry
zero
not_zero
sign
not_sign
kNoCondition
overflow
no_overflow
Uless
Ugreater_equal
equal
not_equal
Uless_equal
Ugreater
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
ueq
nue
cc_always
carry
not_carry
zero
eq
not_zero
ne
nz
sign
not_sign
mi
pl
hi
ls
ge
lt
gt
le
hs
lo
al
cc_default
no_condition
overflow
no_overflow
below
above_equal
equal
not_equal
below_equal
above
negative
positive
parity_even
parity_odd
less
greater_equal
less_equal
greater
always
never
carry
not_carry
zero
not_zero
sign
not_sign
last_condition

Definition at line 448 of file constants-mips.h.

enum ConditionalBranchOp

Enumerator
ConditionalBranchFixed
ConditionalBranchFMask
ConditionalBranchMask
B_cond

Definition at line 661 of file constants-arm64.h.

enum ConditionalCompareImmediateOp

Enumerator
ConditionalCompareImmediateFixed
ConditionalCompareImmediateFMask
ConditionalCompareImmediateMask
CCMN_w_imm
CCMN_x_imm
CCMP_w_imm
CCMP_x_imm

Definition at line 915 of file constants-arm64.h.

enum ConditionalCompareOp

Enumerator
ConditionalCompareMask
CCMN
CCMP

Definition at line 897 of file constants-arm64.h.

enum ConditionalCompareRegisterOp

Enumerator
ConditionalCompareRegisterFixed
ConditionalCompareRegisterFMask
ConditionalCompareRegisterMask
CCMN_w
CCMN_x
CCMP_w
CCMP_x

Definition at line 904 of file constants-arm64.h.

enum ConditionalSelectOp

Enumerator
ConditionalSelectFixed
ConditionalSelectFMask
ConditionalSelectMask
CSEL_w
CSEL_x
CSEL
CSINC_w
CSINC_x
CSINC
CSINV_w
CSINV_x
CSINV
CSNEG_w
CSNEG_x
CSNEG

Definition at line 926 of file constants-arm64.h.

enum ContainedInLattice

Enumerator
kNotYet
kLatticeIn
kLatticeOut
kLatticeUnknown

Definition at line 1223 of file jsregexp.h.

enum ContextLookupFlags

Enumerator
FOLLOW_CONTEXT_CHAIN
FOLLOW_PROTOTYPE_CHAIN
DONT_FOLLOW_CHAINS
FOLLOW_CHAINS

Definition at line 38 of file contexts.h.

enum ContextualMode

Enumerator
NOT_CONTEXTUAL
CONTEXTUAL

Definition at line 184 of file objects.h.

enum ConversionFlags

Enumerator
NO_FLAGS
ALLOW_HEX
ALLOW_OCTAL
ALLOW_IMPLICIT_OCTAL
ALLOW_BINARY
ALLOW_TRAILING_JUNK

Definition at line 113 of file conversions.h.

enum Coprocessor

Enumerator
p0
p1
p2
p3
p4
p5
p6
p7
p8
p9
p10
p11
p12
p13
p14
p15

Definition at line 529 of file assembler-arm.h.

enum CopyHint

Enumerator
kCopyUnknown
kCopyShort
kCopyLong

Definition at line 123 of file macro-assembler-arm64.h.

enum CounterType

Enumerator
Gauge
Cumulative

Definition at line 49 of file instrument-arm64.h.

enum CpuFeature

Enumerator
SSE4_1
SSE3
SSE2
CMOV
VFP3
ARMv7
SUDIV
UNALIGNED_ACCESSES
MOVW_MOVT_IMMEDIATE_LOADS
VFP32DREGS
NEON
SAHF
FPU

Definition at line 420 of file v8globals.h.

enum DataProcessing1SourceOp

Enumerator
DataProcessing1SourceFixed
DataProcessing1SourceFMask
DataProcessing1SourceMask
RBIT
RBIT_w
RBIT_x
REV16
REV16_w
REV16_x
REV
REV_w
REV32_x
REV_x
CLZ
CLZ_w
CLZ_x
CLS
CLS_w
CLS_x

Definition at line 945 of file constants-arm64.h.

enum DataProcessing2SourceOp

Enumerator
DataProcessing2SourceFixed
DataProcessing2SourceFMask
DataProcessing2SourceMask
UDIV_w
UDIV_x
UDIV
SDIV_w
SDIV_x
SDIV
LSLV_w
LSLV_x
LSLV
LSRV_w
LSRV_x
LSRV
ASRV_w
ASRV_x
ASRV
RORV_w
RORV_x
RORV
CRC32B
CRC32H
CRC32W
CRC32X
CRC32CB
CRC32CH
CRC32CW
CRC32CX

Definition at line 968 of file constants-arm64.h.

enum DataProcessing3SourceOp

Enumerator
DataProcessing3SourceFixed
DataProcessing3SourceFMask
DataProcessing3SourceMask
MADD_w
MADD_x
MADD
MSUB_w
MSUB_x
MSUB
SMADDL_x
SMSUBL_x
SMULH_x
UMADDL_x
UMSUBL_x
UMULH_x

Definition at line 1001 of file constants-arm64.h.

enum DebugExtraICState

Enumerator
DEBUG_BREAK
DEBUG_PREPARE_STEP_IN

Definition at line 273 of file objects.h.

enum DebugParameters

Enumerator
NO_PARAM
BREAK
LOG_DISASM
LOG_REGS
LOG_FP_REGS
LOG_SYS_REGS
LOG_WRITE
LOG_STATE
LOG_ALL
TRACE_ENABLE
TRACE_DISABLE
TRACE_OVERRIDE

Definition at line 479 of file instructions-arm64.h.

enum DefaultIsolateStatus

Enumerator
kDefaultIsolateUninitialized
kDefaultIsolateInitialized
kDefaultIsolateCrashIfInitialized

Definition at line 138 of file isolate.cc.

enum DescriptorFlag

Enumerator
ALL_DESCRIPTORS
OWN_DESCRIPTORS

Definition at line 290 of file objects.h.

enum DiscardMoveMode

Enumerator
kDontDiscardForSameWReg
kDiscardForSameWReg

Definition at line 124 of file macro-assembler-arm64.h.

enum DtoaMode

Enumerator
DTOA_SHORTEST
DTOA_FIXED
DTOA_PRECISION

Definition at line 34 of file dtoa.h.

enum ElementInSetsRelation

Enumerator
kInsideNone
kInsideFirst
kInsideSecond
kInsideBoth

Definition at line 248 of file jsregexp.h.

enum ElementsKind

Enumerator
FAST_SMI_ELEMENTS
FAST_HOLEY_SMI_ELEMENTS
FAST_ELEMENTS
FAST_HOLEY_ELEMENTS
FAST_DOUBLE_ELEMENTS
FAST_HOLEY_DOUBLE_ELEMENTS
DICTIONARY_ELEMENTS
SLOPPY_ARGUMENTS_ELEMENTS
EXTERNAL_INT8_ELEMENTS
EXTERNAL_UINT8_ELEMENTS
EXTERNAL_INT16_ELEMENTS
EXTERNAL_UINT16_ELEMENTS
EXTERNAL_INT32_ELEMENTS
EXTERNAL_UINT32_ELEMENTS
EXTERNAL_FLOAT32_ELEMENTS
EXTERNAL_FLOAT64_ELEMENTS
EXTERNAL_UINT8_CLAMPED_ELEMENTS
UINT8_ELEMENTS
INT8_ELEMENTS
UINT16_ELEMENTS
INT16_ELEMENTS
UINT32_ELEMENTS
INT32_ELEMENTS
FLOAT32_ELEMENTS
FLOAT64_ELEMENTS
UINT8_CLAMPED_ELEMENTS
FIRST_ELEMENTS_KIND
LAST_ELEMENTS_KIND
FIRST_FAST_ELEMENTS_KIND
LAST_FAST_ELEMENTS_KIND
FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND
LAST_EXTERNAL_ARRAY_ELEMENTS_KIND
FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND
LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND
TERMINAL_FAST_ELEMENTS_KIND

Definition at line 36 of file elements-kind.h.

enum EnsureElementsMode

Enumerator
DONT_ALLOW_DOUBLE_ELEMENTS
ALLOW_COPIED_DOUBLE_ELEMENTS
ALLOW_CONVERTED_DOUBLE_ELEMENTS

Definition at line 1997 of file objects.h.

enum ExceptionOp

Enumerator
ExceptionFixed
ExceptionFMask
ExceptionMask
HLT
BRK
SVC
HVC
SMC
DCPS1
DCPS2
DCPS3

Definition at line 694 of file constants-arm64.h.

enum Executability

Enumerator
NOT_EXECUTABLE
EXECUTABLE

Definition at line 210 of file v8globals.h.

enum Extend

Enumerator
NO_EXTEND
UXTB
UXTH
UXTW
UXTX
SXTB
SXTH
SXTW
SXTX

Definition at line 359 of file constants-arm64.h.

enum ExtractOp

Enumerator
ExtractFixed
ExtractFMask
ExtractMask
EXTR_w
EXTR_x
EXTR

Definition at line 610 of file constants-arm64.h.

enum FastDtoaMode

Enumerator
FAST_DTOA_SHORTEST
FAST_DTOA_PRECISION

Definition at line 34 of file fast-dtoa.h.

enum FixedArraySubInstanceType

Enumerator
LAST_FIXED_ARRAY_SUB_TYPE

Definition at line 874 of file objects.h.

enum FlagsUpdate

Enumerator
SetFlags
LeaveFlags

Definition at line 319 of file constants-arm64.h.

enum FPCompareOp

Enumerator
FPCompareFixed
FPCompareFMask
FPCompareMask
FCMP_s
FCMP_d
FCMP
FCMP_s_zero
FCMP_d_zero
FCMP_zero
FCMPE_s
FCMPE_d
FCMPE_s_zero
FCMPE_d_zero

Definition at line 1020 of file constants-arm64.h.

enum FPConditionalCompareOp

Enumerator
FPConditionalCompareFixed
FPConditionalCompareFMask
FPConditionalCompareMask
FCCMP_s
FCCMP_d
FCCMP
FCCMPE_s
FCCMPE_d
FCCMPE

Definition at line 1037 of file constants-arm64.h.

enum FPConditionalSelectOp

Enumerator
FPConditionalSelectFixed
FPConditionalSelectFMask
FPConditionalSelectMask
FCSEL_s
FCSEL_d
FCSEL

Definition at line 1050 of file constants-arm64.h.

enum FPDataProcessing1SourceOp

Enumerator
FPDataProcessing1SourceFixed
FPDataProcessing1SourceFMask
FPDataProcessing1SourceMask
FMOV_s
FMOV_d
FMOV
FABS_s
FABS_d
FABS
FNEG_s
FNEG_d
FNEG
FSQRT_s
FSQRT_d
FSQRT
FCVT_ds
FCVT_sd
FRINTN_s
FRINTN_d
FRINTN
FRINTP_s
FRINTP_d
FRINTP
FRINTM_s
FRINTM_d
FRINTM
FRINTZ_s
FRINTZ_d
FRINTZ
FRINTA_s
FRINTA_d
FRINTA
FRINTX_s
FRINTX_d
FRINTX
FRINTI_s
FRINTI_d
FRINTI

Definition at line 1069 of file constants-arm64.h.

enum FPDataProcessing2SourceOp

Enumerator
FPDataProcessing2SourceFixed
FPDataProcessing2SourceFMask
FPDataProcessing2SourceMask
FMUL
FMUL_s
FMUL_d
FDIV
FDIV_s
FDIV_d
FADD
FADD_s
FADD_d
FSUB
FSUB_s
FSUB_d
FMAX
FMAX_s
FMAX_d
FMIN
FMIN_s
FMIN_d
FMAXNM
FMAXNM_s
FMAXNM_d
FMINNM
FMINNM_s
FMINNM_d
FNMUL
FNMUL_s
FNMUL_d

Definition at line 1111 of file constants-arm64.h.

enum FPDataProcessing3SourceOp

Enumerator
FPDataProcessing3SourceFixed
FPDataProcessing3SourceFMask
FPDataProcessing3SourceMask
FMADD_s
FMSUB_s
FNMADD_s
FNMSUB_s
FMADD_d
FMSUB_d
FNMADD_d
FNMSUB_d

Definition at line 1145 of file constants-arm64.h.

enum FPFixedPointConvertOp

Enumerator
FPFixedPointConvertFixed
FPFixedPointConvertFMask
FPFixedPointConvertMask
FCVTZS_fixed
FCVTZS_ws_fixed
FCVTZS_xs_fixed
FCVTZS_wd_fixed
FCVTZS_xd_fixed
FCVTZU_fixed
FCVTZU_ws_fixed
FCVTZU_xs_fixed
FCVTZU_wd_fixed
FCVTZU_xd_fixed
SCVTF_fixed
SCVTF_sw_fixed
SCVTF_sx_fixed
SCVTF_dw_fixed
SCVTF_dx_fixed
UCVTF_fixed
UCVTF_sw_fixed
UCVTF_sx_fixed
UCVTF_dw_fixed
UCVTF_dx_fixed

Definition at line 1231 of file constants-arm64.h.

enum FPImmediateOp

Enumerator
FPImmediateFixed
FPImmediateFMask
FPImmediateMask
FMOV_s_imm
FMOV_d_imm

Definition at line 1060 of file constants-arm64.h.

enum FPIntegerConvertOp

Enumerator
FPIntegerConvertFixed
FPIntegerConvertFMask
FPIntegerConvertMask
FCVTNS
FCVTNS_ws
FCVTNS_xs
FCVTNS_wd
FCVTNS_xd
FCVTNU
FCVTNU_ws
FCVTNU_xs
FCVTNU_wd
FCVTNU_xd
FCVTPS
FCVTPS_ws
FCVTPS_xs
FCVTPS_wd
FCVTPS_xd
FCVTPU
FCVTPU_ws
FCVTPU_xs
FCVTPU_wd
FCVTPU_xd
FCVTMS
FCVTMS_ws
FCVTMS_xs
FCVTMS_wd
FCVTMS_xd
FCVTMU
FCVTMU_ws
FCVTMU_xs
FCVTMU_wd
FCVTMU_xd
FCVTZS
FCVTZS_ws
FCVTZS_xs
FCVTZS_wd
FCVTZS_xd
FCVTZU
FCVTZU_ws
FCVTZU_xs
FCVTZU_wd
FCVTZU_xd
SCVTF
SCVTF_sw
SCVTF_sx
SCVTF_dw
SCVTF_dx
UCVTF
UCVTF_sw
UCVTF_sx
UCVTF_dw
UCVTF_dx
FCVTAS
FCVTAS_ws
FCVTAS_xs
FCVTAS_wd
FCVTAS_xd
FCVTAU
FCVTAU_ws
FCVTAU_xs
FCVTAU_wd
FCVTAU_xd
FMOV_ws
FMOV_sw
FMOV_xd
FMOV_dx

Definition at line 1160 of file constants-arm64.h.

enum FPRounding

Enumerator
FPTieEven
FPPositiveInfinity
FPNegativeInfinity
FPZero
FPTieAway

Definition at line 101 of file instructions-arm64.h.

enum FPUCondition

Enumerator
kNoFPUCondition
F
UN
EQ
UEQ
OLT
ULT
OLE
ULE

Definition at line 534 of file constants-mips.h.

enum FPURoundingMode

Enumerator
RN
RZ
RP
RM
kRoundToNearest
kRoundToZero
kRoundToPlusInf
kRoundToMinusInf

Definition at line 549 of file constants-mips.h.

enum FrameType

Enumerator
JS_FUNCTION
JS_CONSTRUCT
JS_GETTER
JS_SETTER
ARGUMENTS_ADAPTOR
STUB

Definition at line 554 of file hydrogen.h.

enum FreeSpaceTreatmentMode

Enumerator
IGNORE_FREE_SPACE
ZAP_FREE_SPACE

Definition at line 3232 of file mark-compact.cc.

enum FrontendCheckType

Enumerator
PERFORM_INITIAL_CHECKS
SKIP_INITIAL_CHECKS

Definition at line 440 of file stub-cache.h.

enum GarbageCollector

Enumerator
SCAVENGER
MARK_COMPACTOR

Definition at line 208 of file v8globals.h.

enum GenericInstrField

Enumerator
SixtyFourBits
ThirtyTwoBits
FP32
FP64

Definition at line 431 of file constants-arm64.h.

enum GVNFlag

Enumerator
kNumberOfTrackedSideEffects
kNumberOfUntrackedSideEffects
kNumberOfFlags

Definition at line 482 of file hydrogen-instructions.h.

enum HAliasing

Enumerator
kMustAlias
kMayAlias
kNoAlias

Definition at line 36 of file hydrogen-alias-analysis.h.

enum HandlerArgumentsMode

Enumerator
DONT_PASS_ARGUMENTS
PASS_ARGUMENTS

Definition at line 286 of file code-stubs.h.

enum Hint

Enumerator
no_hint
no_hint

Definition at line 425 of file constants-arm.h.

enum Hint

Enumerator
no_hint
no_hint

Definition at line 576 of file constants-mips.h.

enum IcCheckType

Enumerator
ELEMENT
PROPERTY

Definition at line 303 of file stub-cache.h.

enum ImmBranchType

Enumerator
UnknownBranchType
CondBranchType
UncondBranchType
CompareBranchType
TestBranchType

Definition at line 87 of file instructions-arm64.h.

enum InitializationFlag

Enumerator
kNeedsInitialization
kCreatedInitialized

Definition at line 549 of file v8globals.h.

enum InlineCacheHolderFlag

Enumerator
OWN_MAP
PROTOTYPE_MAP

Definition at line 294 of file v8globals.h.

enum InlineCacheState

Enumerator
UNINITIALIZED
PREMONOMORPHIC
MONOMORPHIC
MONOMORPHIC_PROTOTYPE_FAILURE
POLYMORPHIC
MEGAMORPHIC
GENERIC
DEBUG_STUB

Definition at line 263 of file v8globals.h.

enum InlinedSmiCheck

Enumerator
ENABLE_INLINED_SMI_CHECK
DISABLE_INLINED_SMI_CHECK

Definition at line 920 of file ic.h.

enum InliningKind

Enumerator
NORMAL_RETURN
CONSTRUCT_CALL_RETURN
GETTER_CALL_RETURN
SETTER_CALL_RETURN

Definition at line 2057 of file hydrogen-instructions.h.

enum InstanceType

Enumerator
INTERNALIZED_STRING_TYPE
ASCII_INTERNALIZED_STRING_TYPE
CONS_INTERNALIZED_STRING_TYPE
CONS_ASCII_INTERNALIZED_STRING_TYPE
EXTERNAL_INTERNALIZED_STRING_TYPE
EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE
EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE
SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE
SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE
SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE
STRING_TYPE
ASCII_STRING_TYPE
CONS_STRING_TYPE
CONS_ASCII_STRING_TYPE
SLICED_STRING_TYPE
SLICED_ASCII_STRING_TYPE
EXTERNAL_STRING_TYPE
EXTERNAL_ASCII_STRING_TYPE
EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE
SHORT_EXTERNAL_STRING_TYPE
SHORT_EXTERNAL_ASCII_STRING_TYPE
SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE
SYMBOL_TYPE
MAP_TYPE
CODE_TYPE
ODDBALL_TYPE
CELL_TYPE
PROPERTY_CELL_TYPE
HEAP_NUMBER_TYPE
FOREIGN_TYPE
BYTE_ARRAY_TYPE
FREE_SPACE_TYPE
EXTERNAL_INT8_ARRAY_TYPE
EXTERNAL_UINT8_ARRAY_TYPE
EXTERNAL_INT16_ARRAY_TYPE
EXTERNAL_UINT16_ARRAY_TYPE
EXTERNAL_INT32_ARRAY_TYPE
EXTERNAL_UINT32_ARRAY_TYPE
EXTERNAL_FLOAT32_ARRAY_TYPE
EXTERNAL_FLOAT64_ARRAY_TYPE
EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE
FIXED_INT8_ARRAY_TYPE
FIXED_UINT8_ARRAY_TYPE
FIXED_INT16_ARRAY_TYPE
FIXED_UINT16_ARRAY_TYPE
FIXED_INT32_ARRAY_TYPE
FIXED_UINT32_ARRAY_TYPE
FIXED_FLOAT32_ARRAY_TYPE
FIXED_FLOAT64_ARRAY_TYPE
FIXED_UINT8_CLAMPED_ARRAY_TYPE
FIXED_DOUBLE_ARRAY_TYPE
FILLER_TYPE
DECLARED_ACCESSOR_DESCRIPTOR_TYPE
DECLARED_ACCESSOR_INFO_TYPE
EXECUTABLE_ACCESSOR_INFO_TYPE
ACCESSOR_PAIR_TYPE
ACCESS_CHECK_INFO_TYPE
INTERCEPTOR_INFO_TYPE
CALL_HANDLER_INFO_TYPE
FUNCTION_TEMPLATE_INFO_TYPE
OBJECT_TEMPLATE_INFO_TYPE
SIGNATURE_INFO_TYPE
TYPE_SWITCH_INFO_TYPE
ALLOCATION_SITE_TYPE
ALLOCATION_MEMENTO_TYPE
SCRIPT_TYPE
CODE_CACHE_TYPE
POLYMORPHIC_CODE_CACHE_TYPE
TYPE_FEEDBACK_INFO_TYPE
ALIASED_ARGUMENTS_ENTRY_TYPE
BOX_TYPE
DEBUG_INFO_TYPE
BREAK_POINT_INFO_TYPE
FIXED_ARRAY_TYPE
CONSTANT_POOL_ARRAY_TYPE
SHARED_FUNCTION_INFO_TYPE
JS_MESSAGE_OBJECT_TYPE
JS_FUNCTION_PROXY_TYPE
JS_PROXY_TYPE
JS_VALUE_TYPE
JS_DATE_TYPE
JS_OBJECT_TYPE
JS_CONTEXT_EXTENSION_OBJECT_TYPE
JS_GENERATOR_OBJECT_TYPE
JS_MODULE_TYPE
JS_GLOBAL_OBJECT_TYPE
JS_BUILTINS_OBJECT_TYPE
JS_GLOBAL_PROXY_TYPE
JS_ARRAY_TYPE
JS_ARRAY_BUFFER_TYPE
JS_TYPED_ARRAY_TYPE
JS_DATA_VIEW_TYPE
JS_SET_TYPE
JS_MAP_TYPE
JS_WEAK_MAP_TYPE
JS_WEAK_SET_TYPE
JS_REGEXP_TYPE
JS_FUNCTION_TYPE
FIRST_TYPE
LAST_TYPE
FIRST_NAME_TYPE
LAST_NAME_TYPE
FIRST_UNIQUE_NAME_TYPE
LAST_UNIQUE_NAME_TYPE
FIRST_NONSTRING_TYPE
FIRST_EXTERNAL_ARRAY_TYPE
LAST_EXTERNAL_ARRAY_TYPE
FIRST_FIXED_TYPED_ARRAY_TYPE
LAST_FIXED_TYPED_ARRAY_TYPE
LAST_DATA_TYPE
FIRST_JS_RECEIVER_TYPE
LAST_JS_RECEIVER_TYPE
FIRST_JS_OBJECT_TYPE
LAST_JS_OBJECT_TYPE
FIRST_JS_PROXY_TYPE
LAST_JS_PROXY_TYPE
FIRST_SPEC_OBJECT_TYPE
LAST_SPEC_OBJECT_TYPE
FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
LAST_NONCALLABLE_SPEC_OBJECT_TYPE
NUM_OF_CALLABLE_SPEC_OBJECT_TYPES

Definition at line 659 of file objects.h.

enum InstrumentState

Enumerator
InstrumentStateDisable
InstrumentStateEnable

Definition at line 43 of file instrument-arm64.h.

enum InterruptFlag

Enumerator
INTERRUPT
DEBUGBREAK
DEBUGCOMMAND
PREEMPT
TERMINATE
GC_REQUEST
FULL_DEOPT
INSTALL_CODE
API_INTERRUPT
DEOPT_MARKED_ALLOCATION_SITES

Definition at line 38 of file execution.h.

enum KeyCollectionType

Enumerator
LOCAL_ONLY
INCLUDE_PROTOS

Definition at line 277 of file handles.h.

enum KeyedAccessStoreMode

Enumerator
STANDARD_STORE
STORE_TRANSITION_SMI_TO_OBJECT
STORE_TRANSITION_SMI_TO_DOUBLE
STORE_TRANSITION_DOUBLE_TO_OBJECT
STORE_TRANSITION_HOLEY_SMI_TO_OBJECT
STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE
STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT
STORE_AND_GROW_NO_TRANSITION
STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT
STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE
STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT
STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT
STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE
STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT
STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS
STORE_NO_TRANSITION_HANDLE_COW

Definition at line 164 of file objects.h.

enum KeyedStoreCheckMap

Enumerator
kDontCheckMap
kCheckMap

Definition at line 572 of file ic.h.

enum KeyedStoreIncrementLength

Enumerator
kDontIncrementLength
kIncrementLength

Definition at line 578 of file ic.h.

enum LeaveExitFrameMode

Enumerator
EMIT_RETURN
NO_EMIT_RETURN

Definition at line 55 of file macro-assembler-mips.h.

enum LFlag

Enumerator
Long
Short

Definition at line 317 of file constants-arm.h.

enum LiFlags

Enumerator
OPTIMIZE_SIZE
CONSTANT_SIZE

Definition at line 85 of file macro-assembler-mips.h.

enum LinkRegisterStatus

Enumerator
kLRHasNotBeenSaved
kLRHasBeenSaved
kLRHasNotBeenSaved
kLRHasBeenSaved

Definition at line 63 of file macro-assembler-arm.h.

enum LinkRegisterStatus

Enumerator
kLRHasNotBeenSaved
kLRHasBeenSaved
kLRHasNotBeenSaved
kLRHasBeenSaved

Definition at line 116 of file macro-assembler-arm64.h.

enum LoadKeyedHoleMode

Enumerator
NEVER_RETURN_HOLE
ALLOW_RETURN_HOLE

Definition at line 6275 of file hydrogen-instructions.h.

enum LoadLiteralOp

Enumerator
LoadLiteralFixed
LoadLiteralFMask
LoadLiteralMask
LDR_w_lit
LDR_x_lit
LDRSW_x_lit
PRFM_lit
LDR_s_lit
LDR_d_lit

Definition at line 797 of file constants-arm64.h.

enum LoadStoreAnyOp

Enumerator
LoadStoreAnyFMask
LoadStoreAnyFixed

Definition at line 720 of file constants-arm64.h.

enum LoadStoreOp

Enumerator
LoadStoreOpMask
LOAD_STORE_OP_LIST
PRFM

Definition at line 841 of file constants-arm64.h.

enum LoadStorePairAnyOp

Enumerator
LoadStorePairAnyFMask
LoadStorePairAnyFixed

Definition at line 726 of file constants-arm64.h.

enum LoadStorePairNonTemporalOp

Enumerator
LoadStorePairNonTemporalFixed
LoadStorePairNonTemporalFMask
LoadStorePairNonTemporalMask
STNP_w
LDNP_w
STNP_x
LDNP_x
STNP_s
LDNP_s
STNP_d
LDNP_d

Definition at line 782 of file constants-arm64.h.

enum LoadStorePairOffsetOp

Enumerator
LoadStorePairOffsetFixed
LoadStorePairOffsetFMask
LoadStorePairOffsetMask

Definition at line 772 of file constants-arm64.h.

enum LoadStorePairOp

Enumerator
LoadStorePairMask
LoadStorePairLBit

Definition at line 743 of file constants-arm64.h.

enum LoadStorePairPostIndexOp

Enumerator
LoadStorePairPostIndexFixed
LoadStorePairPostIndexFMask
LoadStorePairPostIndexMask

Definition at line 752 of file constants-arm64.h.

enum LoadStorePairPreIndexOp

Enumerator
LoadStorePairPreIndexFixed
LoadStorePairPreIndexFMask
LoadStorePairPreIndexMask

Definition at line 762 of file constants-arm64.h.

enum LoadStorePostIndex

Enumerator
LoadStorePostIndexFixed
LoadStorePostIndexFMask
LoadStorePostIndexMask

Definition at line 851 of file constants-arm64.h.

enum LoadStorePreIndex

Enumerator
LoadStorePreIndexFixed
LoadStorePreIndexFMask
LoadStorePreIndexMask

Definition at line 862 of file constants-arm64.h.

enum LoadStoreRegisterOffset

Enumerator
LoadStoreRegisterOffsetFixed
LoadStoreRegisterOffsetFMask
LoadStoreRegisterOffsetMask
PRFM_reg

Definition at line 885 of file constants-arm64.h.

enum LoadStoreUnscaledOffsetOp

Enumerator
LoadStoreUnscaledOffsetFixed
LoadStoreUnscaledOffsetFMask
LoadStoreUnscaledOffsetMask

Definition at line 830 of file constants-arm64.h.

enum LoadStoreUnsignedOffset

Enumerator
LoadStoreUnsignedOffsetFixed
LoadStoreUnsignedOffsetFMask
LoadStoreUnsignedOffsetMask
PRFM_unsigned

Definition at line 873 of file constants-arm64.h.

enum LoggingAndProfiling

Enumerator
LOGGING_AND_PROFILING_ENABLED
LOGGING_AND_PROFILING_DISABLED

Definition at line 2176 of file heap.cc.

enum LogicalImmediateOp

Enumerator
LogicalImmediateFixed
LogicalImmediateFMask
LogicalImmediateMask
AND_w_imm
AND_x_imm
ORR_w_imm
ORR_x_imm
EOR_w_imm
EOR_x_imm
ANDS_w_imm
ANDS_x_imm

Definition at line 530 of file constants-arm64.h.

enum LogicalOp

Enumerator
LogicalOpMask
NOT
AND
BIC
ORR
ORN
EOR
EON
ANDS
BICS

Definition at line 516 of file constants-arm64.h.

enum LogicalShiftedOp

Enumerator
LogicalShiftedFixed
LogicalShiftedFMask
LogicalShiftedMask
AND_w
AND_x
AND_shift
BIC_w
BIC_x
BIC_shift
ORR_w
ORR_x
ORR_shift
ORN_w
ORN_x
ORN_shift
EOR_w
EOR_x
EOR_shift
EON_w
EON_x
EON_shift
ANDS_w
ANDS_x
ANDS_shift
BICS_w
BICS_x
BICS_shift

Definition at line 545 of file constants-arm64.h.

enum LSDataSize

Enumerator
LSByte
LSHalfword
LSWord
LSDoubleWord

Definition at line 78 of file instructions-arm64.h.

enum MarkingParity

Enumerator
NO_MARKING_PARITY
ODD_MARKING_PARITY
EVEN_MARKING_PARITY

Definition at line 302 of file objects.h.

enum MarksHandling

Enumerator
TRANSFER_MARKS
IGNORE_MARKS

Definition at line 2182 of file heap.cc.

enum MayAccessDecision

Enumerator
YES
NO
UNKNOWN

Definition at line 745 of file isolate.cc.

enum MemBarrierOp

Enumerator
MemBarrierFixed
MemBarrierFMask
MemBarrierMask
DSB
DMB
ISB

Definition at line 710 of file constants-arm64.h.

enum MinimumCapacity

Enumerator
USE_DEFAULT_MINIMUM_CAPACITY
USE_CUSTOM_MINIMUM_CAPACITY

Definition at line 203 of file v8globals.h.

enum MinusZeroMode

Enumerator
TREAT_MINUS_ZERO_AS_ZERO
FAIL_ON_MINUS_ZERO

Definition at line 561 of file v8globals.h.

enum MiscInstructionsBits74

Enumerator
BX
BXJ
BLX
BKPT
CLZ

Definition at line 173 of file constants-arm.h.

enum MoveWideImmediateOp

Enumerator
MoveWideImmediateFixed
MoveWideImmediateFMask
MoveWideImmediateMask
MOVN
MOVZ
MOVK
MOVN_w
MOVN_x
MOVZ_w
MOVZ_x
MOVK_w
MOVK_x

Definition at line 576 of file constants-arm64.h.

enum NativesFlag

Enumerator
NOT_NATIVES_CODE
NATIVES_CODE

Definition at line 220 of file v8globals.h.

enum NativeType

Enumerator
CORE
EXPERIMENTAL
D8
TEST

Definition at line 38 of file natives.h.

enum NeonDataType

Enumerator
NeonS8
NeonS16
NeonS32
NeonU8
NeonU16
NeonU32
NeonDataTypeSizeMask
NeonDataTypeUMask

Definition at line 324 of file constants-arm.h.

enum NeonListType

Enumerator
nlt_1
nlt_2
nlt_3
nlt_4

Definition at line 335 of file constants-arm.h.

enum NeonSize

Enumerator
Neon8
Neon16
Neon32
Neon64

Definition at line 342 of file constants-arm.h.

enum NilValue

Enumerator
kNullValue
kUndefinedValue

Definition at line 133 of file v8.h.

enum NormalizedMapSharingMode

Enumerator
UNIQUE_NORMALIZED_MAP
SHARED_NORMALIZED_MAP

Definition at line 260 of file objects.h.

enum NumberUntagDMode

Enumerator
NUMBER_CANDIDATE_IS_SMI
NUMBER_CANDIDATE_IS_ANY_TAGGED

Definition at line 718 of file lithium.h.

enum ObjectToDoubleFlags

Enumerator
NO_OBJECT_TO_DOUBLE_FLAGS
OBJECT_NOT_SMI
AVOID_NANS_AND_INFINITIES

Definition at line 69 of file macro-assembler-mips.h.

enum Opcode

Enumerator
AND
EOR
SUB
RSB
ADD
ADC
SBC
RSC
TST
TEQ
CMP
CMN
ORR
MOV
BIC
MVN
SPECIAL
REGIMM
J
JAL
BEQ
BNE
BLEZ
BGTZ
ADDI
ADDIU
SLTI
SLTIU
ANDI
ORI
XORI
LUI
COP1
BEQL
BNEL
BLEZL
BGTZL
SPECIAL2
SPECIAL3
LB
LH
LWL
LW
LBU
LHU
LWR
SB
SH
SWL
SW
SWR
LWC1
LDC1
PREF
SWC1
SDC1
COP1X

Definition at line 152 of file constants-arm.h.

enum Opcode

Enumerator
AND
EOR
SUB
RSB
ADD
ADC
SBC
RSC
TST
TEQ
CMP
CMN
ORR
MOV
BIC
MVN
SPECIAL
REGIMM
J
JAL
BEQ
BNE
BLEZ
BGTZ
ADDI
ADDIU
SLTI
SLTIU
ANDI
ORI
XORI
LUI
COP1
BEQL
BNEL
BLEZL
BGTZL
SPECIAL2
SPECIAL3
LB
LH
LWL
LW
LBU
LHU
LWR
SB
SH
SWL
SW
SWR
LWC1
LDC1
PREF
SWC1
SDC1
COP1X

Definition at line 265 of file constants-mips.h.

enum OutputMode

Enumerator
UNKNOWN
CONSOLE
ODS

Definition at line 645 of file platform-win32.cc.

enum OverwriteMode

Enumerator
NO_OVERWRITE
OVERWRITE_LEFT
OVERWRITE_RIGHT

Definition at line 690 of file ic.h.

enum ParseRestriction

Enumerator
NO_PARSE_RESTRICTION
ONLY_SINGLE_FUNCTION_LITERAL

Definition at line 43 of file compiler.h.

enum PCRelAddressingOp

Enumerator
PCRelAddressingFixed
PCRelAddressingFMask
PCRelAddressingMask
ADR
ADRP

Definition at line 439 of file constants-arm64.h.

enum PerIsolateAssertType

Enumerator
JAVASCRIPT_EXECUTION_ASSERT
JAVASCRIPT_EXECUTION_THROWS
ALLOCATION_FAILURE_ASSERT

Definition at line 50 of file assert-scope.h.

enum PerThreadAssertType

Enumerator
HEAP_ALLOCATION_ASSERT
HANDLE_ALLOCATION_ASSERT
HANDLE_DEREFERENCE_ASSERT
DEFERRED_HANDLE_DEREFERENCE_ASSERT
CODE_DEPENDENCY_CHANGE_ASSERT
LAST_PER_THREAD_ASSERT_TYPE

Definition at line 40 of file assert-scope.h.

enum PretenureFlag

Enumerator
NOT_TENURED
TENURED

Definition at line 201 of file v8globals.h.

enum PrologueFrameMode

Enumerator
BUILD_FUNCTION_FRAME
BUILD_STUB_FRAME

Definition at line 957 of file frames.h.

enum PropertyAccessType

Enumerator
LOAD
STORE

Definition at line 229 of file hydrogen-instructions.h.

enum PropertyDescriptorIndices

Enumerator
IS_ACCESSOR_INDEX
VALUE_INDEX
GETTER_INDEX
SETTER_INDEX
WRITABLE_INDEX
ENUMERABLE_INDEX
CONFIGURABLE_INDEX
DESCRIPTOR_SIZE

Definition at line 1918 of file runtime.cc.

enum PropertyNormalizationMode

Enumerator
CLEAR_INOBJECT_PROPERTIES
KEEP_INOBJECT_PROPERTIES

Definition at line 252 of file objects.h.

enum PropertyType

Enumerator
NORMAL
FIELD
CONSTANT
CALLBACKS
HANDLER
INTERCEPTOR
TRANSITION
NONEXISTENT

Definition at line 70 of file property-details.h.

enum PrototypeCheckType

Enumerator
CHECK_ALL_MAPS
SKIP_RECEIVER

Definition at line 302 of file stub-cache.h.

enum RAStatus

Enumerator
kRAHasNotBeenSaved
kRAHasBeenSaved

Definition at line 97 of file macro-assembler-mips.h.

enum Reg31Mode

Enumerator
Reg31IsStackPointer
Reg31IsZeroRegister

Definition at line 113 of file instructions-arm64.h.

enum RegisterKind

Enumerator
UNALLOCATED_REGISTERS
GENERAL_REGISTERS
DOUBLE_REGISTERS

Definition at line 144 of file lithium-allocator.h.

enum RegisterValueType

Enumerator
REGISTER_VALUE_IS_SMI
REGISTER_VALUE_IS_INT32

Definition at line 46 of file macro-assembler-ia32.h.

enum RememberedSetAction

Enumerator
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET

Definition at line 42 of file macro-assembler-ia32.h.

enum RememberedSetAction

Enumerator
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET

Definition at line 53 of file macro-assembler-x64.h.

enum RememberedSetAction

Enumerator
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET

Definition at line 61 of file macro-assembler-arm.h.

enum RememberedSetAction

Enumerator
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET

Definition at line 95 of file macro-assembler-mips.h.

enum RememberedSetAction

Enumerator
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET
EMIT_REMEMBERED_SET
OMIT_REMEMBERED_SET

Definition at line 114 of file macro-assembler-arm64.h.

enum RemovableSimulate

Enumerator
REMOVABLE_SIMULATE
FIXED_SIMULATE

Definition at line 1865 of file hydrogen-instructions.h.

enum RobustnessFlag

Enumerator
ROBUST_STRING_TRAVERSAL
FAST_STRING_TRAVERSAL

Definition at line 8495 of file objects.h.

enum SaveFPRegsMode

Enumerator
kDontSaveFPRegs
kSaveFPRegs

Definition at line 226 of file assembler.h.

enum SBit

Enumerator
SetCC
LeaveCC

Definition at line 237 of file constants-arm.h.

enum ScaleFactor

Enumerator
times_1
times_2
times_4
times_8
times_int_size
times_half_pointer_size
times_pointer_size
times_twice_pointer_size
times_1
times_2
times_4
times_8
times_int_size
times_pointer_size

Definition at line 371 of file assembler-x64.h.

enum ScaleFactor

Enumerator
times_1
times_2
times_4
times_8
times_int_size
times_half_pointer_size
times_pointer_size
times_twice_pointer_size
times_1
times_2
times_4
times_8
times_int_size
times_pointer_size

Definition at line 375 of file assembler-ia32.h.

enum ScopeType

Enumerator
EVAL_SCOPE
FUNCTION_SCOPE
MODULE_SCOPE
GLOBAL_SCOPE
CATCH_SCOPE
BLOCK_SCOPE
WITH_SCOPE

Definition at line 443 of file v8globals.h.

enum SearchMode

Enumerator
ALL_ENTRIES
VALID_ENTRIES

Definition at line 3574 of file objects.h.

enum SecondaryField

Enumerator
SLL
MOVCI
SRL
SRA
SLLV
SRLV
SRAV
JR
JALR
MOVZ
MOVN
BREAK
MFHI
MFLO
MULT
MULTU
DIV
DIVU
ADD
ADDU
SUB
SUBU
AND
OR
XOR
NOR
SLT
SLTU
TGE
TGEU
TLT
TLTU
TEQ
TNE
MUL
CLZ
CLO
EXT
INS
BLTZ
BGEZ
BLTZAL
BGEZAL
MFC1
CFC1
MFHC1
MTC1
CTC1
MTHC1
BC1
S
D
W
L
PS
ROUND_L_S
TRUNC_L_S
CEIL_L_S
FLOOR_L_S
ROUND_W_S
TRUNC_W_S
CEIL_W_S
FLOOR_W_S
CVT_D_S
CVT_W_S
CVT_L_S
CVT_PS_S
ADD_D
SUB_D
MUL_D
DIV_D
SQRT_D
ABS_D
MOV_D
NEG_D
ROUND_L_D
TRUNC_L_D
CEIL_L_D
FLOOR_L_D
ROUND_W_D
TRUNC_W_D
CEIL_W_D
FLOOR_W_D
CVT_S_D
CVT_W_D
CVT_L_D
C_F_D
C_UN_D
C_EQ_D
C_UEQ_D
C_OLT_D
C_ULT_D
C_OLE_D
C_ULE_D
CVT_S_W
CVT_D_W
CVT_S_L
CVT_D_L
MADD_D
NULLSF

Definition at line 318 of file constants-mips.h.

enum SemiSpaceId

Enumerator
kFromSpace
kToSpace

Definition at line 2033 of file spaces.h.

enum SeqStringSetCharCheckIndexType

Enumerator
kIndexIsSmi
kIndexIsInteger32

Definition at line 125 of file macro-assembler-arm64.h.

enum SetPropertyMode

Enumerator
SET_PROPERTY
DEFINE_PROPERTY

Definition at line 2008 of file objects.h.

enum Shift

Enumerator
NO_SHIFT
LSL
LSR
ASR
ROR

Definition at line 351 of file constants-arm64.h.

enum ShiftOp

Enumerator
LSL
LSR
ASR
ROR
RRX
kNumberOfShifts

Definition at line 251 of file constants-arm.h.

enum SimpleTransitionFlag

Enumerator
SIMPLE_TRANSITION
FULL_TRANSITION

Definition at line 282 of file objects.h.

enum SkipListRebuildingMode

Enumerator
REBUILD_SKIP_LIST
IGNORE_SKIP_LIST

Definition at line 3226 of file mark-compact.cc.

enum SmiCheck

Enumerator
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK

Definition at line 43 of file macro-assembler-ia32.h.

enum SmiCheck

Enumerator
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK

Definition at line 54 of file macro-assembler-x64.h.

enum SmiCheck

Enumerator
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK

Definition at line 62 of file macro-assembler-arm.h.

enum SmiCheck

Enumerator
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK

Definition at line 96 of file macro-assembler-mips.h.

enum SmiCheck

Enumerator
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK
INLINE_SMI_CHECK
OMIT_SMI_CHECK

Definition at line 115 of file macro-assembler-arm64.h.

enum SmiCheckType

Enumerator
DONT_DO_SMI_CHECK
DO_SMI_CHECK

Definition at line 437 of file v8globals.h.

enum SmiOperationConstraint

Enumerator
PRESERVE_SOURCE_REGISTER
BAILOUT_ON_NO_OVERFLOW
BAILOUT_ON_OVERFLOW
NUMBER_OF_CONSTRAINTS

Definition at line 56 of file macro-assembler-x64.h.

enum SoftwareInterruptCodes

Enumerator
kCallRtRedirected
kBreakpoint
kStopCode
call_rt_redirected

Definition at line 187 of file constants-mips.h.

enum SoftwareInterruptCodes

Enumerator
kCallRtRedirected
kBreakpoint
kStopCode
call_rt_redirected

Definition at line 356 of file constants-arm.h.

enum SRegister

Enumerator
CPSR
SPSR

Definition at line 244 of file constants-arm.h.

enum SRegisterField

Enumerator
CPSR_c
CPSR_x
CPSR_s
CPSR_f
SPSR_c
SPSR_x
SPSR_s
SPSR_f

Definition at line 267 of file constants-arm.h.

enum StackArgumentsAccessorReceiverMode

Enumerator
ARGUMENTS_CONTAIN_RECEIVER
ARGUMENTS_DONT_CONTAIN_RECEIVER

Definition at line 71 of file codegen-x64.h.

enum StateTag

Enumerator
JS
GC
COMPILER
OTHER
EXTERNAL
IDLE

Definition at line 364 of file v8globals.h.

enum StatusFlags

Enumerator
NoFlag
NFlag
ZFlag
CFlag
VFlag
NZFlag
NCFlag
NVFlag
ZCFlag
ZVFlag
CVFlag
NZCFlag
NZVFlag
NCVFlag
ZCVFlag
NZCVFlag
FPEqualFlag
FPLessThanFlag
FPGreaterThanFlag
FPUnorderedFlag

Definition at line 324 of file constants-arm64.h.

enum StoreBufferEvent

Enumerator
kStoreBufferFullEvent
kStoreBufferStartScanningPagesEvent
kStoreBufferScanningPageEvent

Definition at line 301 of file v8globals.h.

enum StoreFieldOrKeyedMode

Enumerator
INITIALIZING_STORE
STORE_TO_INITIALIZED_ENTRY

Definition at line 6496 of file hydrogen-instructions.h.

enum StoreMode

Enumerator
ALLOW_AS_CONSTANT
FORCE_FIELD

Definition at line 244 of file objects.h.

enum StrictMode

Enumerator
SLOPPY
STRICT

Definition at line 415 of file globals.h.

enum StringAddFlags

Enumerator
STRING_ADD_CHECK_NONE
STRING_ADD_CHECK_LEFT
STRING_ADD_CHECK_RIGHT
STRING_ADD_CHECK_BOTH

Definition at line 1271 of file code-stubs.h.

enum StringIndexFlags

Enumerator
STRING_INDEX_IS_NUMBER
STRING_INDEX_IS_ARRAY_INDEX

Definition at line 1699 of file code-stubs.h.

enum StringRepresentationTag

Enumerator
kSeqStringTag
kConsStringTag
kExternalStringTag
kSlicedStringTag

Definition at line 616 of file objects.h.

enum StubFunctionMode

Enumerator
NOT_JS_FUNCTION_STUB_MODE
JS_FUNCTION_STUB_MODE

Definition at line 285 of file code-stubs.h.

enum SweepingMode

Enumerator
SWEEP_ONLY
SWEEP_AND_VISIT_LIVE_OBJECTS

Definition at line 3220 of file mark-compact.cc.

enum SystemHint

Enumerator
NOP
YIELD
WFE
WFI
SEV
SEVL

Definition at line 371 of file constants-arm64.h.

enum SystemHintOp

Enumerator
SystemHintFixed
SystemHintFMask
SystemHintMask
HINT

Definition at line 686 of file constants-arm64.h.

enum SystemOp

Enumerator
SystemFixed
SystemFMask

Definition at line 673 of file constants-arm64.h.

enum SystemRegister

Enumerator
NZCV
FPCR

Definition at line 397 of file constants-arm64.h.

enum SystemSysRegOp

Enumerator
SystemSysRegFixed
SystemSysRegFMask
SystemSysRegMask
MRS
MSR

Definition at line 678 of file constants-arm64.h.

enum TaggingMode

Enumerator
TAG_RESULT
DONT_TAG_RESULT
TAG_RESULT
DONT_TAG_RESULT

Definition at line 53 of file macro-assembler-arm.h.

enum TaggingMode

Enumerator
TAG_RESULT
DONT_TAG_RESULT
TAG_RESULT
DONT_TAG_RESULT

Definition at line 61 of file macro-assembler-mips.h.

enum TargetAddressStorageMode

Enumerator
CAN_INLINE_TARGET_ADDRESS
NEVER_INLINE_TARGET_ADDRESS
CAN_INLINE_TARGET_ADDRESS
NEVER_INLINE_TARGET_ADDRESS

Definition at line 84 of file macro-assembler-arm.h.

enum TargetAddressStorageMode

Enumerator
CAN_INLINE_TARGET_ADDRESS
NEVER_INLINE_TARGET_ADDRESS
CAN_INLINE_TARGET_ADDRESS
NEVER_INLINE_TARGET_ADDRESS

Definition at line 117 of file macro-assembler-arm64.h.

enum TestBranchOp

Enumerator
TestBranchFixed
TestBranchFMask
TestBranchMask
TBZ
TBNZ

Definition at line 652 of file constants-arm64.h.

enum TransitionFlag

Enumerator
INSERT_TRANSITION
OMIT_TRANSITION

Definition at line 267 of file objects.h.

enum TypeCode

Enumerator
UNCLASSIFIED
BUILTIN
RUNTIME_FUNCTION
IC_UTILITY
DEBUG_ADDRESS
STATS_COUNTER
TOP_ADDRESS
C_BUILTIN
EXTENSION
ACCESSOR
RUNTIME_ENTRY
STUB_CACHE_TABLE
LAZY_DEOPTIMIZATION

Definition at line 38 of file serialize.h.

enum TypedArraySetResultCodes

Enumerator
TYPED_ARRAY_SET_TYPED_ARRAY_SAME_TYPE
TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING
TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING
TYPED_ARRAY_SET_NON_TYPED_ARRAY

Definition at line 1167 of file runtime.cc.

enum TypeofState

Enumerator
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF

Definition at line 38 of file codegen-x64.h.

enum TypeofState

Enumerator
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF

Definition at line 38 of file codegen-arm.h.

enum TypeofState

Enumerator
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF
INSIDE_TYPEOF
NOT_INSIDE_TYPEOF

Definition at line 40 of file codegen-mips.h.

enum UnallocatedOp

Enumerator
UnallocatedFixed
UnallocatedFMask

Definition at line 1264 of file constants-arm64.h.

enum UnconditionalBranchOp

Enumerator
UnconditionalBranchFixed
UnconditionalBranchFMask
UnconditionalBranchMask
B
BL

Definition at line 620 of file constants-arm64.h.

enum UnconditionalBranchToRegisterOp

Enumerator
UnconditionalBranchToRegisterFixed
UnconditionalBranchToRegisterFMask
UnconditionalBranchToRegisterMask
BR
BLR
RET

Definition at line 629 of file constants-arm64.h.

enum UnimplementedOp

Enumerator
UnimplementedFixed
UnimplementedFMask

Definition at line 1259 of file constants-arm64.h.

enum UntagMode

Enumerator
kNotSpeculativeUntag
kSpeculativeUntag

Definition at line 121 of file macro-assembler-arm64.h.

enum VariableMode

Enumerator
VAR
CONST_LEGACY
LET
CONST
MODULE
INTERNAL
TEMPORARY
DYNAMIC
DYNAMIC_GLOBAL
DYNAMIC_LOCAL

Definition at line 465 of file v8globals.h.

enum VFPConversionMode

Enumerator
kFPSCRRounding
kDefaultRoundToZero

Definition at line 377 of file constants-arm.h.

enum VFPRegPrecision

Enumerator
kSinglePrecision
kDoublePrecision

Definition at line 370 of file constants-arm.h.

enum VFPRoundingMode

Enumerator
RN
RP
RM
RZ
kRoundToNearest
kRoundToPlusInf
kRoundToMinusInf
kRoundToZero

Definition at line 399 of file constants-arm.h.

enum VisitMode

Enumerator
VISIT_ALL
VISIT_ALL_IN_SCAVENGE
VISIT_ALL_IN_SWEEP_NEWSPACE
VISIT_ONLY_STRONG

Definition at line 212 of file v8globals.h.

enum WriteBarrierMode

Enumerator
SKIP_WRITE_BARRIER
UPDATE_WRITE_BARRIER

Definition at line 240 of file objects.h.

Function Documentation

int v8::internal::__tsan_atomic128_compare_exchange_strong	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128 *	c,
		__tsan_atomic128	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_compare_exchange_val	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	c,
		__tsan_atomic128	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

int v8::internal::__tsan_atomic128_compare_exchange_weak	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128 *	c,
		__tsan_atomic128	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_exchange	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_fetch_add	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_fetch_and	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_fetch_nand	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_fetch_or	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_fetch_xor	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128 v8::internal::__tsan_atomic128_load	(	const volatile __tsan_atomic128 *	a,
		__tsan_memory_order	mo
	)

void v8::internal::__tsan_atomic128_store	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

int v8::internal::__tsan_atomic16_compare_exchange_strong	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16 *	c,
		__tsan_atomic16	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_compare_exchange_val	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	c,
		__tsan_atomic16	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

int v8::internal::__tsan_atomic16_compare_exchange_weak	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16 *	c,
		__tsan_atomic16	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_exchange	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_fetch_add	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_fetch_and	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_fetch_nand	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_fetch_or	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_fetch_xor	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16 v8::internal::__tsan_atomic16_load	(	const volatile __tsan_atomic16 *	a,
		__tsan_memory_order	mo
	)

void v8::internal::__tsan_atomic16_store	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

int v8::internal::__tsan_atomic32_compare_exchange_strong	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32 *	c,
		__tsan_atomic32	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_compare_exchange_val	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	c,
		__tsan_atomic32	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

int v8::internal::__tsan_atomic32_compare_exchange_weak	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32 *	c,
		__tsan_atomic32	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_exchange	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

Referenced by Acquire_AtomicExchange(), and Release_AtomicExchange().

__tsan_atomic32 v8::internal::__tsan_atomic32_fetch_add	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_fetch_and	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_fetch_nand	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_fetch_or	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_fetch_xor	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32 v8::internal::__tsan_atomic32_load	(	const volatile __tsan_atomic32 *	a,
		__tsan_memory_order	mo
	)

void v8::internal::__tsan_atomic32_store	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

int v8::internal::__tsan_atomic64_compare_exchange_strong	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64 *	c,
		__tsan_atomic64	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_compare_exchange_val	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	c,
		__tsan_atomic64	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

int v8::internal::__tsan_atomic64_compare_exchange_weak	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64 *	c,
		__tsan_atomic64	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_exchange	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

Referenced by Acquire_AtomicExchange(), and Release_AtomicExchange().

__tsan_atomic64 v8::internal::__tsan_atomic64_fetch_add	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_fetch_and	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_fetch_nand	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_fetch_or	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_fetch_xor	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64 v8::internal::__tsan_atomic64_load	(	const volatile __tsan_atomic64 *	a,
		__tsan_memory_order	mo
	)

void v8::internal::__tsan_atomic64_store	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

int v8::internal::__tsan_atomic8_compare_exchange_strong	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8 *	c,
		__tsan_atomic8	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_compare_exchange_val	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	c,
		__tsan_atomic8	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

int v8::internal::__tsan_atomic8_compare_exchange_weak	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8 *	c,
		__tsan_atomic8	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_exchange	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_fetch_add	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_fetch_and	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_fetch_nand	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_fetch_or	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_fetch_xor	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8 v8::internal::__tsan_atomic8_load	(	const volatile __tsan_atomic8 *	a,
		__tsan_memory_order	mo
	)

void v8::internal::__tsan_atomic8_store	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

void v8::internal::__tsan_atomic_signal_fence

(

__tsan_memory_order

mo

)

void v8::internal::__tsan_atomic_thread_fence

(

__tsan_memory_order

mo

)

T v8::internal::Abs

(

T

a

)

Definition at line 241 of file utils.h.

Referenced by MultiplierAndShift::MultiplierAndShift(), TEST(), and WhichPowerOf2Abs().

v8::internal::ACCESSORS	(	AccessorInfo	,
		expected_receiver_type	,
		Object	,
		kExpectedReceiverTypeOffset
	)

kSerializedDataOffset v8::internal::ACCESSORS	(	DeclaredAccessorInfo	,
		descriptor	,
		DeclaredAccessorDescriptor	,
		kDescriptorOffset
	)

kSerializedDataOffset kPrototypeTemplateOffset v8::internal::ACCESSORS	(	FunctionTemplateInfo	,
		named_property_handler	,
		Object	,
		kNamedPropertyHandlerOffset
	)

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset v8::internal::ACCESSORS	(	FunctionTemplateInfo	,
		instance_template	,
		Object	,
		kInstanceTemplateOffset
	)

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset v8::internal::ACCESSORS	(	FunctionTemplateInfo	,
		access_check_info	,
		Object	,
		kAccessCheckInfoOffset
	)

v8::internal::ACCESSORS	(	SharedFunctionInfo	,
		optimized_code_map	,
		Object	,
		kOptimizedCodeMapOffset
	)

v8::internal::ACCESSORS	(	JSFunction	,
		prototype_or_initial_map	,
		Object	,
		kPrototypeOrInitialMapOffset
	)

Definition at line 5579 of file objects-inl.h.

References Map::cast().

v8::internal::ACCESSORS	(	TypeFeedbackInfo	,
		feedback_vector	,
		FixedArray	,
		kFeedbackVectorOffset
	)

Definition at line 6774 of file objects-inl.h.

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset v8::internal::ACCESSORS_TO_SMI	(	AllocationSite	,
		pretenure_create_count	,
		kPretenureCreateCountOffset
	)

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset kDependentCodeOffset v8::internal::ACCESSORS_TO_SMI	(	Script	,
		eval_from_instructions_offset	,
		kEvalFrominstructionsOffsetOffset
	)

Definition at line 5062 of file objects-inl.h.

References flags, and BooleanBit::get().

Atomic32 v8::internal::Acquire_AtomicExchange ( volatile Atomic32 *  ptr, Atomic32  new_value  )

inline

Definition at line 237 of file atomicops_internals_tsan.h.

References __tsan_atomic32_exchange(), and __tsan_memory_order_acquire.

Atomic64 v8::internal::Acquire_AtomicExchange ( volatile Atomic64 *  ptr, Atomic64  new_value  )

inline

Definition at line 319 of file atomicops_internals_tsan.h.

References __tsan_atomic64_exchange(), and __tsan_memory_order_acquire.

AtomicWord v8::internal::Acquire_CompareAndSwap ( volatile AtomicWord *  ptr, AtomicWord  old_value, AtomicWord  new_value  )

inline

Definition at line 74 of file atomicops_internals_atomicword_compat.h.

References Acquire_CompareAndSwap().

Atomic32 Acquire_CompareAndSwap ( volatile Atomic32 *  ptr, Atomic32  old_value, Atomic32  new_value  )

inline

Definition at line 120 of file atomicops_internals_arm64_gcc.h.

Referenced by Acquire_CompareAndSwap(), CallOnceImpl(), and MemoryChunk::TryParallelSweeping().

Atomic64 Acquire_CompareAndSwap ( volatile Atomic64 *  ptr, Atomic64  old_value, Atomic64  new_value  )

inline

Definition at line 286 of file atomicops_internals_arm64_gcc.h.

AtomicWord v8::internal::Acquire_Load ( volatile const AtomicWord *  ptr )

inline

Definition at line 108 of file atomicops_internals_atomicword_compat.h.

References Acquire_Load().

Atomic32 Acquire_Load ( volatile const Atomic32 *  ptr )

inline

Definition at line 196 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Referenced by Acquire_Load(), CallOnce(), CallOnceImpl(), MemoryChunk::next_chunk(), MemoryChunk::parallel_sweeping(), SamplingCircularQueue< T, Length >::Peek(), MemoryChunk::prev_chunk(), SweeperThread::Run(), OptimizingCompilerThread::Run(), and SamplingCircularQueue< T, Length >::StartEnqueue().

Atomic64 Acquire_Load ( volatile const Atomic64 *  ptr )

inline

Definition at line 359 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

void v8::internal::Acquire_Store ( volatile AtomicWord *  ptr, AtomicWord  value  )

inline

Definition at line 93 of file atomicops_internals_atomicword_compat.h.

References Acquire_Store().

void Acquire_Store ( volatile Atomic32 *  ptr, Atomic32  value  )

inline

Definition at line 182 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Referenced by Acquire_Store().

void Acquire_Store ( volatile Atomic64 *  ptr, Atomic64  value  )

inline

Definition at line 345 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Handle< FixedArray > AddKeysFromJSArray	(	Handle< FixedArray >	content,
		Handle< JSArray >	array
	)

Definition at line 127 of file handles.cc.

References CALL_HEAP_FUNCTION.

Referenced by GetKeysInFixedArrayFor().

ContainedInLattice AddRange	(	ContainedInLattice	containment,
		const int *	ranges,
		int	ranges_length,
		Interval	new_range
	)

Definition at line 114 of file jsregexp.cc.

References ASSERT, Combine(), Interval::from(), kLatticeIn, kLatticeOut, kLatticeUnknown, String::kMaxUtf16CodeUnit, and Interval::to().

Referenced by AddressToTraceMap::MoveObject(), and BoyerMoorePositionInfo::SetInterval().

T v8::internal::AddressFrom ( intptr_t  x )

inline

Definition at line 129 of file utils.h.

References T.

void AddWeakObjectToCodeDependency	(	Heap *	heap,
		Handle< Object >	object,
		Handle< Code >	code
	)

Definition at line 765 of file handles.cc.

References Heap::AddWeakObjectToCodeDependency(), CALL_HEAP_FUNCTION_VOID, Heap::EnsureWeakObjectToCodeTable(), DependentCode::Insert(), Heap::isolate(), DependentCode::kWeaklyEmbeddedGroup, and Heap::LookupWeakObjectToCodeDependency().

bool v8::internal::AdvanceToNonspace ( UnicodeCache *  unicode_cache, Iterator *  current, EndMark  end  )

inline

Definition at line 127 of file conversions-inl.h.

References UnicodeCache::IsWhiteSpaceOrLineTerminator().

Referenced by InternalStringToDouble(), InternalStringToInt(), and InternalStringToIntDouble().

v8::internal::ALIAS_REGISTER	(	Register	,
		ip0	,
		x16
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		ip1	,
		x17
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		wip0	,
		w16
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		wip1	,
		w17
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		root	,
		x26
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		rr	,
		x26
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		cp	,
		x27
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		jssp	,
		x28
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		wjssp	,
		w28
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		fp	,
		x29
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		lr	,
		x30
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		xzr	,
		x31
	)

v8::internal::ALIAS_REGISTER	(	Register	,
		wzr	,
		w31
	)

v8::internal::ALIAS_REGISTER	(	FPRegister	,
		fp_zero	,
		d15
	)

v8::internal::ALIAS_REGISTER	(	FPRegister	,
		crankshaft_fp_scratch	,
		d30
	)

v8::internal::ALIAS_REGISTER	(	FPRegister	,
		fp_scratch	,
		d31
	)

void * AlignedAlloc	(	size_t	size,
		size_t	alignment
	)

Definition at line 108 of file allocation.cc.

References ASSERT, FatalProcessOutOfMemory(), IsPowerOf2(), NULL, and V8_ALIGNOF.

Referenced by ProfilerEventsProcessor::operator new().

void AlignedFree

(

void *

ptr

)

Definition at line 125 of file allocation.cc.

Referenced by ProfilerEventsProcessor::operator delete().

T v8::internal::AlignUp	(	T	pointer,
		size_t	alignment
	)

Definition at line 153 of file utils.h.

References ASSERT, RoundUp(), and T.

Referenced by Assembler::EmitStringData().

const char * AllocationSpaceName

(

AllocationSpace

space

)

Definition at line 707 of file mark-compact.cc.

References CELL_SPACE, CODE_SPACE, LO_SPACE, MAP_SPACE, NEW_SPACE, NULL, OLD_DATA_SPACE, OLD_POINTER_SPACE, PROPERTY_CELL_SPACE, and UNREACHABLE.

Referenced by MarkCompactCollector::CollectEvacuationCandidates().

Operand v8::internal::ApiParameterOperand

(

int

index

)

int AppendChars	(	const char *	filename,
		const char *	str,
		int	size,
		bool	verbose
	)

Definition at line 214 of file v8utils.cc.

References OS::FOpen(), NULL, OS::PrintError(), and WriteCharsToFile().

bool AreAliased	(	Register	r1,
		Register	r2,
		Register	r3,
		Register	r4
	)

bool v8::internal::AreAliased	(	const CPURegister &	reg1,
		const CPURegister &	reg2,
		const CPURegister &	reg3 = NoReg,
		const CPURegister &	reg4 = NoReg,
		const CPURegister &	reg5 = NoReg,
		const CPURegister &	reg6 = NoReg,
		const CPURegister &	reg7 = NoReg,
		const CPURegister &	reg8 = NoReg
	)

Referenced by RegisterDump::Dump(), MacroAssembler::Ldnp(), and MacroAssembler::Ldp().

bool v8::internal::AreSameSizeAndType	(	const CPURegister &	reg1,
		const CPURegister &	reg2,
		const CPURegister &	reg3 = NoCPUReg,
		const CPURegister &	reg4 = NoCPUReg,
		const CPURegister &	reg5 = NoCPUReg,
		const CPURegister &	reg6 = NoCPUReg,
		const CPURegister &	reg7 = NoCPUReg,
		const CPURegister &	reg8 = NoCPUReg
	)

Referenced by CPURegList::CPURegList(), Assembler::LoadPairNonTemporalOpFor(), Assembler::LoadPairOpFor(), Assembler::StorePairNonTemporalOpFor(), and Assembler::StorePairOpFor().

int v8::internal::ArithmeticShiftRight ( int  x, int  s  )

inline

Definition at line 111 of file utils.h.

Referenced by RUNTIME_FUNCTION(), and ParserTraits::ShortcutNumericLiteralBinaryExpression().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for ARMv7

(

ARM

only

)

Handle< Object > ArrayConstructInitializeElements	(	Handle< JSArray >	array,
		Arguments *	args
	)

Definition at line 1950 of file elements.cc.

References ALLOW_CONVERTED_DOUBLE_ELEMENTS, Handle< T >::cast(), JSObject::EnsureCanContainElements(), FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, FAST_SMI_ELEMENTS, Smi::FromInt(), GetHoleyElementsKind(), JSArray::Initialize(), IsFastDoubleElementsKind(), IsFastHoleyElementsKind(), JSObject::kInitialMaxFastElementArray, JSArray::kPreallocatedArrayElements, mode(), Factory::NewFixedArrayWithHoles(), Factory::NewFixedDoubleArray(), obj, JSArray::SetElementsLength(), SKIP_WRITE_BARRIER, JSObject::TransitionElementsKind(), and UNREACHABLE.

void ArrayNativeCode	(	MacroAssembler *	masm,
		Label *	call_generic_code
	)

void v8::internal::ArrayNativeCode	(	MacroAssembler *	masm,
		bool	construct_call,
		Label *	call_generic_code
	)

int v8::internal::AsciiAlphaToLower ( uc32  c )

inline

Definition at line 40 of file char-predicates-inl.h.

Referenced by IsHexDigit(), and IsRegExpWord().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if available

(

ARM

only

)

Referenced by Assembler::set_constant_pool_available(), and TEST().

AtomicWord v8::internal::Barrier_AtomicIncrement ( volatile AtomicWord *  ptr, AtomicWord  increment  )

inline

Definition at line 68 of file atomicops_internals_atomicword_compat.h.

References Barrier_AtomicIncrement().

Atomic32 Barrier_AtomicIncrement ( volatile Atomic32 *  ptr, Atomic32  increment  )

inline

Definition at line 111 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier(), and NoBarrier_AtomicIncrement().

Referenced by Barrier_AtomicIncrement().

Atomic64 Barrier_AtomicIncrement ( volatile Atomic64 *  ptr, Atomic64  increment  )

inline

Definition at line 277 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier(), and NoBarrier_AtomicIncrement().

void BignumDtoa	(	double	v,
		BignumDtoaMode	mode,
		int	requested_digits,
		Vector< char >	buffer,
		int *	length,
		int *	decimal_point
	)

Definition at line 92 of file bignum-dtoa.cc.

References ASSERT, BIGNUM_DTOA_FIXED, BIGNUM_DTOA_PRECISION, BIGNUM_DTOA_SHORTEST, Double::Exponent(), Bignum::kMaxSignificantBits, Double::Significand(), and UNREACHABLE.

Referenced by DoubleToAscii(), and TEST().

int v8::internal::BinarySearch	(	T *	array,
		Name *	name,
		int	low,
		int	high,
		int	valid_entries
	)

Definition at line 2450 of file objects-inl.h.

References ALL_ENTRIES, ASSERT, Name::Equals(), and Name::Hash().

Dest v8::internal::BitCast ( const Source &  source )

inline

Definition at line 941 of file utils.h.

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPESymInitialize

)

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPESymGetSearchPath

)

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPEStackWalk64

)

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPESymGetSymFromAddr64

)

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPESymGetLineFromAddr64

)

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPEModule32FirstW

)

typedef v8::internal::BOOL

(

__stdcall *

DLL_FUNC_TYPEModule32NextW

)

kInstanceClassNameOffset v8::internal::BOOL_ACCESSORS	(	FunctionTemplateInfo	,
		flag	,
		hidden_prototype	,
		kHiddenPrototypeBit
	)

kInstanceClassNameOffset kNeedsAccessCheckBit v8::internal::BOOL_ACCESSORS	(	FunctionTemplateInfo	,
		flag	,
		read_only_prototype	,
		kReadOnlyPrototypeBit
	)

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit v8::internal::BOOL_ACCESSORS	(	FunctionTemplateInfo	,
		flag	,
		do_not_cache	,
		kDoNotCacheBit
	)

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit v8::internal::BOOL_ACCESSORS	(	SharedFunctionInfo	,
		start_position_and_type	,
		is_toplevel	,
		kIsTopLevelBit
	)

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation v8::internal::BOOL_ACCESSORS	(	SharedFunctionInfo	,
		compiler_hints	,
		allows_lazy_compilation_without_context	,
		kAllowLazyCompilationWithoutContext
	)

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments v8::internal::BOOL_ACCESSORS	(	SharedFunctionInfo	,
		compiler_hints	,
		has_duplicate_parameters	,
		kHasDuplicateParameters
	)

v8::internal::BOOL_ACCESSORS	(	SharedFunctionInfo	,
		compiler_hints	,
		live_objects_may_exist	,
		kLiveObjectsMayExist
	)

Definition at line 5230 of file objects-inl.h.

v8::internal::BOOL_ACCESSORS	(	SharedFunctionInfo	,
		compiler_hints	,
		inline_builtin	,
		kInlineBuiltin
	)

kNameShouldPrintAsAnonymous v8::internal::BOOL_ACCESSORS	(	SharedFunctionInfo	,
		compiler_hints	,
		dont_optimize	,
		kDontOptimize
	)

Definition at line 5289 of file objects-inl.h.

v8::internal::BOOL_GETTER	(	SharedFunctionInfo	,
		compiler_hints	,
		optimization_disabled	,
		kOptimizationDisabled
	)

Definition at line 5241 of file objects-inl.h.

References code(), compiler_hints, and BooleanBit::set().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out bugs

(

implies" "--

force_marking_deque_overflows

)

v8::internal::BUILTIN

(

Illegal

)

Definition at line 187 of file builtins.cc.

References UNREACHABLE.

v8::internal::BUILTIN

(

EmptyFunction

)

Definition at line 193 of file builtins.cc.

v8::internal::BUILTIN

(

ArrayPush

)

Definition at line 396 of file builtins.cc.

References ASSERT, Handle< T >::cast(), Smi::cast(), ElementsAccessor::CopyElements(), Smi::FromInt(), Handle< T >::is_null(), IsFastSmiOrObjectElementsKind(), ElementsAccessor::kCopyToEndAndInitializeToHole, Smi::kMaxValue, mode(), and Object::Number().

v8::internal::BUILTIN

(

ArrayPop

)

Definition at line 513 of file builtins.cc.

References ASSERT, Handle< T >::cast(), Smi::cast(), Smi::FromInt(), ElementsAccessor::Get(), Object::GetElement(), handle(), Handle< T >::is_null(), NULL, RETURN_IF_EMPTY_HANDLE, and ElementsAccessor::SetLength().

v8::internal::BUILTIN

(

ArrayShift

)

Definition at line 545 of file builtins.cc.

References ASSERT, Heap::CanMoveObjectStart(), Handle< T >::cast(), Smi::cast(), Smi::FromInt(), ElementsAccessor::Get(), Handle< T >::is_null(), Heap::MoveElements(), NULL, and RETURN_IF_EMPTY_HANDLE.

v8::internal::BUILTIN

(

ArrayUnshift

)

Definition at line 593 of file builtins.cc.

References ASSERT, Handle< T >::cast(), Smi::cast(), ElementsAccessor::CopyElements(), DONT_ALLOW_DOUBLE_ELEMENTS, JSObject::EnsureCanContainElements(), Smi::FromInt(), Handle< T >::is_null(), ElementsAccessor::kCopyToEndAndInitializeToHole, Smi::kMaxValue, mode(), Heap::MoveElements(), and NULL.

v8::internal::BUILTIN

(

ArraySlice

)

Definition at line 653 of file builtins.cc.

References ASSERT, Handle< T >::cast(), Smi::cast(), ElementsAccessor::CopyElements(), ElementsAccessor::ForKind(), GetPackedElementsKind(), handle(), IsHoleyElementsKind(), std::isnan(), Heap::kArgumentsLengthIndex, kMaxInt, Max(), and Min().

v8::internal::BUILTIN

(

ArraySplice

)

Definition at line 783 of file builtins.cc.

References ASSERT, Heap::CanMoveObjectStart(), Handle< T >::cast(), Smi::cast(), HeapNumber::cast(), LargeObjectSpace::Contains(), ElementsAccessor::CopyElements(), Smi::FromInt(), handle(), Handle< T >::is_null(), IsFastDoubleElementsKind(), std::isnan(), ElementsAccessor::kCopyToEndAndInitializeToHole, kMaxInt, Smi::kMaxValue, Heap::lo_space(), Max(), Min(), mode(), Heap::MoveElements(), and Smi::value().

v8::internal::BUILTIN

(

ArrayConcat

)

Definition at line 993 of file builtins.cc.

References ASSERT, Handle< T >::cast(), Smi::cast(), JSObject::cast(), DONT_INITIALIZE_ARRAY_ELEMENTS, ElementsAccessor::ForKind(), GetHoleyElementsKind(), GetInitialFastElementsKind(), INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE, IsFastDoubleElementsKind(), IsFastHoleyElementsKind(), IsFastObjectElementsKind(), IsMoreGeneralElementsKindTransition(), kBitsPerInt, FixedArray::kMaxLength, FixedDoubleArray::kMaxLength, mode(), STATIC_ASSERT(), USE(), and Smi::value().

v8::internal::BUILTIN

(

StrictModePoisonPill

)

Definition at line 1076 of file builtins.cc.

References NULL.

v8::internal::BUILTIN

(

HandleApiCall

)

Definition at line 1221 of file builtins.cc.

v8::internal::BUILTIN

(

HandleApiCallConstruct

)

Definition at line 1226 of file builtins.cc.

v8::internal::BUILTIN

(

HandleApiCallAsFunction

)

Definition at line 1290 of file builtins.cc.

v8::internal::BUILTIN

(

HandleApiCallAsConstructor

)

Definition at line 1297 of file builtins.cc.

Handle< Object > CacheInitialJSArrayMaps	(	Handle< Context >	native_context,
		Handle< Map >	initial_map
	)

Definition at line 9694 of file objects.cc.

References CALL_HEAP_FUNCTION, HeapObject::GetIsolate(), and Object.

LSDataSize v8::internal::CalcLSPairDataSize

(

LoadStorePairOp

op

)

Referenced by Instruction::SizeLSPair().

Handle< FixedArray > CalculateLineEnds	(	Handle< String >	src,
		bool	with_last_line
	)

Definition at line 328 of file handles.cc.

References ASSERT, Isolate::factory(), FlattenGetString(), Smi::FromInt(), String::FlatContent::IsAscii(), String::FlatContent::IsFlat(), Factory::NewFixedArray(), String::FlatContent::ToOneByteVector(), and String::FlatContent::ToUC16Vector().

void v8::internal::CallOnce ( OnceType *  once, NoArgFunction  init_func  )

inline

Definition at line 105 of file once.h.

References Acquire_Load(), CallOnceImpl(), NULL, and ONCE_STATE_DONE.

Referenced by BuiltinFunctionTable::functions(), ThreadSafeInitOnceTrait::Init(), and Heap::SetUp().

void v8::internal::CallOnce ( OnceType *  once, typename OneArgFunction< Arg * >::type  init_func, Arg *  arg  )

inline

Definition at line 113 of file once.h.

References Acquire_Load(), CallOnceImpl(), and ONCE_STATE_DONE.

void CallOnceImpl	(	OnceType *	once,
		PointerArgFunction	init_func,
		void *	arg
	)

Definition at line 42 of file once.cc.

References Acquire_CompareAndSwap(), Acquire_Load(), ONCE_STATE_DONE, ONCE_STATE_EXECUTING_FUNCTION, ONCE_STATE_UNINITIALIZED, and Release_Store().

Referenced by CallOnce().

bool v8::internal::CanBeZero

(

HValue *

right

)

Definition at line 9114 of file hydrogen.cc.

Referenced by HGraphBuilder::BuildBinaryOperation(), and V8_FINAL< kOperandKind, kNumCachedOperands >::CanBeMinusZero().

bool v8::internal::CanTransitionToMoreGeneralFastElementsKind ( ElementsKind  elements_kind, bool  allow_only_packed  )

inline

Definition at line 264 of file elements-kind.h.

References FAST_ELEMENTS, IsFastElementsKind(), and TERMINAL_FAST_ELEMENTS_KIND.

Referenced by Map::FindTransitionedMap().

MemOperand v8::internal::CFunctionArgumentOperand ( int  index )

inline

Definition at line 130 of file macro-assembler-mips.h.

References ASSERT, kCArgSlotCount, kCArgsSlotsSize, kPointerSize, and sp.

bool v8::internal::CharCompare ( const PatternChar *  pattern, const SubjectChar *  subject, int  length  )

inline

Definition at line 253 of file string-search.h.

References ASSERT.

void CheckArrayAbuse	(	JSObject *	obj,
		const char *	op,
		uint32_t	key,
		bool	allow_appending
	)

Definition at line 520 of file elements.cc.

References JSArray::cast(), DoubleToInt32(), FastD2UI(), FastI2D(), Smi::FromInt(), HeapObject::GetIsolate(), NULL, Object::Number(), and PrintF().

Referenced by ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::Get().

double ClobberDoubleRegisters	(	double	x1,
		double	x2,
		double	x3,
		double	x4
	)

Definition at line 120 of file arguments.cc.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra code

(

assertions

)

Referenced by IC::address(), RegExpCompiler::Assemble(), TypeFeedbackOracle::BinaryType(), BOOL_GETTER(), HOptimizedGraphBuilder::BuildGraph(), Isolate::CaptureSimpleStackTrace(), check(), Heap::ClearAllICsByKind(), LChunk::Codegen(), TypeFeedbackOracle::CollectReceiverTypes(), CPURegList::Combine(), CompareNilIC::CompareNil(), TypeFeedbackOracle::CompareType(), LoadIC::CompileHandler(), StoreIC::CompileHandler(), IC::ComputeHandler(), TypeFeedbackOracle::CountType(), Factory::CreateApiFunction(), Heap::CreateCode(), OptimizedCompileJob::CreateGraph(), SharedFunctionInfo::DisableOptimization(), SharedFunctionInfo::DontAdaptArguments(), RegisterDump::dreg_bits(), SharedFunctionInfo::EnableDeoptimizationSupport(), InnerPointerToCodeCache::GcSafeCastToCode(), OptimizedCompileJob::GenerateCode(), SharedFunctionInfo::GetCodeFromOptimizedCodeMap(), Code::GetCodeFromTargetAddress(), CodeCache::GetIndex(), TypeFeedbackOracle::GetStoreMode(), SharedFunctionInfo::has_deoptimization_support(), OptimizingCompilerThread::InstallOptimizedFunctions(), RegExpImpl::IrregexpExecRaw(), SharedFunctionInfo::is_compiled(), SharedFunctionInfo::IsInlineable(), TypeFeedbackOracle::LoadIsStub(), TypeFeedbackOracle::LoadIsUninitialized(), Heap::LookupSingleCharacterStringFromCode(), FullCodeGenerator::MakeCode(), Factory::NewFunctionFromSharedFunctionInfo(), SharedFunctionInfo::profiler_ticks(), ProfileGenerator::RecordTickSample(), RelocIterator::RelocIterator(), CPURegList::Remove(), SharedFunctionInfo::ReplaceCode(), SharedFunctionInfo::ResetForNewContext(), RUNTIME_FUNCTION(), RegisterDump::sreg_bits(), TypeFeedbackOracle::StoreIsKeyedPolymorphic(), TypeFeedbackOracle::StoreIsUninitialized(), TEST(), SharedFunctionInfo::TryReenableOptimization(), JavaScriptFrame::unchecked_code(), InternalFrame::unchecked_code(), LoadIC::UpdateCaches(), SharedFunctionInfo::VerifyBailoutId(), IndexedReferencesExtractor::VisitCodeEntry(), RegisterDump::wreg(), and RegisterDump::xreg().

bool v8::internal::CodeGenerationFromStringsAllowed	(	Isolate *	isolate,
		Handle< Context >	context
	)

Definition at line 9820 of file runtime.cc.

References ASSERT, NULL, and Utils::ToLocal().

Referenced by RUNTIME_FUNCTION().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash collisions

(

with snapshots this option cannot override the baked-in

seed

)

ContainedInLattice v8::internal::Combine ( ContainedInLattice  a, ContainedInLattice  b  )

inline

Definition at line 1231 of file jsregexp.h.

Referenced by AddRange(), and V8_FINAL< kOperandKind, kNumCachedOperands >::IsSubtypeOf().

int v8::internal::Compare	(	const T &	a,
		const T &	b
	)

Definition at line 161 of file utils.h.

Referenced by SplayTree< Config, AllocationPolicy >::FindGreatestLessThan(), SplayTree< Config, AllocationPolicy >::FindLeastGreaterThan(), SplayTree< Config, AllocationPolicy >::Insert(), SplayTree< Config, AllocationPolicy >::Move(), and SplayTree< Config, AllocationPolicy >::Splay().

int v8::internal::CompareChars ( const lchar *  lhs, const rchar *  rhs, int  chars  )

inline

Definition at line 852 of file utils.h.

References ASSERT, and CompareCharsUnsigned().

Referenced by String::IsOneByteEqualTo(), and String::IsTwoByteEqualTo().

int v8::internal::CompareCharsUnsigned ( const lchar *  lhs, const rchar *  rhs, int  chars  )

inline

Definition at line 824 of file utils.h.

Referenced by CompareChars().

uint32_t v8::internal::ComputeIntegerHash ( uint32_t  key, uint32_t  seed  )

inline

Definition at line 322 of file utils.h.

Referenced by check(), ComputePointerHash(), HeapObjectsMap::GenerateId(), InnerPointerToCodeCache::GetCacheEntry(), CodeEntry::GetCallUid(), UnseededNumberDictionaryShape::Hash(), UnseededNumberDictionaryShape::HashForObject(), SeededNumberDictionaryShape::SeededHash(), and SeededNumberDictionaryShape::SeededHashForObject().

uint32_t v8::internal::ComputeLongHash ( uint64_t  key )

inline

Definition at line 335 of file utils.h.

Referenced by Object::GetHash().

uint32_t v8::internal::ComputePointerHash ( void *  ptr )

inline

Definition at line 347 of file utils.h.

References ComputeIntegerHash().

Referenced by HeapObjectsMap::FindEntry(), HeapObjectsMap::FindOrAddEntry(), HeapObjectsMap::FindUntrackedObjects(), HeapObjectsMap::MoveObject(), and HeapObjectsMap::RemoveDeadEntries().

Handle<String> v8::internal::ConcatStringContent	(	Handle< StringType >	result,
		Handle< String >	first,
		Handle< String >	second
	)

Definition at line 350 of file factory.cc.

References String::WriteToFlat().

bool v8::internal::ConstantIsObject	(	HConstant *	constant,
		Isolate *	isolate
	)

Definition at line 3224 of file hydrogen-instructions.cc.

References FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, Isolate::heap(), and LAST_NONCALLABLE_SPEC_OBJECT_TYPE.

MemOperand v8::internal::ContextMemOperand ( Register  context, int  index  )

inline

Definition at line 2241 of file macro-assembler-arm64.h.

References Context::SlotOffset().

Referenced by GlobalObjectMemOperand().

Operand ContextOperand ( Register  context, int  index  )

inline

Definition at line 1587 of file macro-assembler-arm.h.

References Context::SlotOffset().

Referenced by GlobalObjectOperand().

void v8::internal::CopyBytes ( T *  dst, const T *  src, size_t  num_bytes  )

inline

Definition at line 176 of file v8utils.h.

References ASSERT, OS::kMinComplexMemCopy, Max(), OS::MemCopy(), Min(), STATIC_ASSERT(), and T.

void v8::internal::CopyBytes ( uint8_t *  target, uint8_t *  source  )

inline

Definition at line 1309 of file runtime.cc.

Referenced by Heap::CopyCode(), Code::CopyFrom(), Deoptimizer::EnsureCodeForDeoptimizationEntry(), ScriptData::New(), RUNTIME_FUNCTION(), and TEST().

void v8::internal::CopyChars	(	sinkchar *	dest,
		const sourcechar *	src,
		int	chars
	)

Definition at line 279 of file v8utils.h.

References ASSERT, and CopyCharsUnsigned().

Referenced by Heap::AllocateStringFromOneByte(), Heap::AllocateStringFromTwoByte(), and String::WriteToFlat().

void v8::internal::CopyCharsUnsigned	(	sinkchar *	dest,
		const sourcechar *	src,
		int	chars
	)

Definition at line 306 of file v8utils.h.

References ASSERT, OS::kMinComplexMemCopy, and OS::MemCopy().

Referenced by CopyChars().

void v8::internal::CopyWords ( T *  dst, const T *  src, size_t  num_words  )

inline

Definition at line 130 of file v8utils.h.

References ASSERT, kPointerSize, Max(), OS::MemCopy(), Min(), STATIC_ASSERT(), and T.

Referenced by Heap::CopyBlock().

int v8::internal::CountLeadingSignBits	(	int64_t	value,
		int	width
	)

int v8::internal::CountLeadingZeros	(	uint64_t	value,
		int	width
	)

int v8::internal::CountSetBits	(	uint64_t	value,
		int	width
	)

Referenced by CPURegList::Count(), MacroAssembler::DecodeField(), NumRegs(), PopulateFPRegisterArray(), PopulateRegisterArray(), MacroAssembler::TestAndBranchIfAllClear(), and MacroAssembler::TestAndBranchIfAnySet().

int v8::internal::CountTrailingZeros	(	uint64_t	value,
		int	width
	)

Referenced by MacroAssembler::Claim(), MacroAssembler::ClaimBySMI(), MacroAssembler::Drop(), and MacroAssembler::DropBySMI().

UnaryMathFunction v8::internal::CreateExpFunction

(

)

UnaryMathFunction v8::internal::CreateSqrtFunction

(

)

Vector< StackFrame * > CreateStackMap	(	Isolate *	isolate,
		Zone *	zone
	)

Definition at line 1643 of file frames.cc.

References List< T, ZoneAllocationPolicy >::Add(), StackFrameIterator::Advance(), and List< T, ZoneAllocationPolicy >::ToVector().

Vector<const char> v8::internal::CStrVector ( const char *  data )

inline

Definition at line 574 of file utils.h.

References StrLength().

Referenced by StringStream::Add(), Shell::CreateEvaluationContext(), Factory::EmergencyNewError(), Oddball::Initialize(), Factory::InternalizeUtf8String(), Heap::InternalizeUtf8String(), CompleteParserRecorder::LogMessage(), Heap::NumberToString(), JSFunction::PassesFilter(), ParserTraits::ReportMessageAt(), RUNTIME_FUNCTION(), TEST(), TestParserSync(), BreakIterator::UnpackBreakIterator(), Collator::UnpackCollator(), DateFormat::UnpackDateFormat(), and NumberFormat::UnpackNumberFormat().

double v8::internal::DataViewConvertValue< double >

(

double

value

)

Definition at line 1490 of file runtime.cc.

float v8::internal::DataViewConvertValue< float >

(

double

value

)

Definition at line 1484 of file runtime.cc.

int16_t v8::internal::DataViewConvertValue< int16_t >

(

double

value

)

Definition at line 1454 of file runtime.cc.

References DoubleToInt32().

int32_t v8::internal::DataViewConvertValue< int32_t >

(

double

value

)

Definition at line 1460 of file runtime.cc.

References DoubleToInt32().

int8_t v8::internal::DataViewConvertValue< int8_t >

(

double

value

)

Definition at line 1448 of file runtime.cc.

References DoubleToInt32().

uint16_t v8::internal::DataViewConvertValue< uint16_t >

(

double

value

)

Definition at line 1472 of file runtime.cc.

References DoubleToUint32().

uint32_t v8::internal::DataViewConvertValue< uint32_t >

(

double

value

)

Definition at line 1478 of file runtime.cc.

References DoubleToUint32().

uint8_t v8::internal::DataViewConvertValue< uint8_t >

(

double

value

)

Definition at line 1466 of file runtime.cc.

References DoubleToUint32().

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreCallbackProperty
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadPropertyWithInterceptorOnly
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadPropertyWithInterceptorForLoad
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadPropertyWithInterceptorForCall
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreInterceptorProperty
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedLoadPropertyWithInterceptor
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedLoadIC_MissFromStubFailure
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedStoreIC_MissFromStubFailure
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		UnaryOpIC_Miss
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreIC_MissFromStubFailure
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		ElementsTransitionAndStoreIC_Miss
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		BinaryOpIC_Miss
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		BinaryOpIC_MissWithAllocationSite
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		CompareNilIC_Miss
	)

v8::internal::DECLARE_RUNTIME_FUNCTION	(	MaybeObject *	,
		ToBooleanIC_Miss
	)

int v8::internal::DecodeConstantPoolLength ( int  instr )

inline

Definition at line 48 of file constants-arm.h.

References ASSERT, kConstantPoolMarker, and kConstantPoolMarkerMask.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file DEFINE_args	(	js_arguments	,
		"Pass all remaining arguments to the script. Alias for \"--\"."
	)

DEFINE_bool	(	use_strict	,
		false	,
		"enforce strict mode"
	)

enable upcoming ES6 features DEFINE_bool	(	harmony_typeof	,
		false	,
		"enable harmony semantics for typeof"
	)

enable upcoming ES6 features enable harmony block scoping DEFINE_bool	(	harmony_modules	,
		false	,
		"enable harmony modules (implies block scoping)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies DEFINE_bool	(	harmony_collections	,
		false	,
		"enable harmony collections (sets, maps)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators DEFINE_bool	(	harmony_iteration	,
		false	,
		"enable harmony iteration (for-of)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string DEFINE_bool	(	harmony_arrays	,
		false	,
		"enable harmony arrays"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions DEFINE_bool	(	harmony	,
		false	,
		"enable all harmony features (except typeof)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths DEFINE_bool	(	packed_arrays	,
		true	,
		"optimizes arrays that have no holes"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values DEFINE_bool	(	compiled_keyed_dictionary_loads	,
		true	,
		"use optimizing compiler to generate keyed dictionary load stubs"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string DEFINE_bool	(	pretenuring	,
		true	,
		"allocate objects in old space"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new DEFINE_bool	(	allocation_site_pretenuring	,
		true	,
		"pretenure with allocation sites"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions DEFINE_bool	(	trace_pretenuring_statistics	,
		false	,
		"trace allocation site pretenuring statistics"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values DEFINE_bool	(	track_double_fields	,
		true	,
		"track fields with double values"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values DEFINE_bool	(	track_computed_fields	,
		true	,
		"track computed boilerplate fields"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields DEFINE_bool	(	smi_binop	,
		true	,
		"support smi representation in binary operations"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed DEFINE_bool	(	unbox_double_arrays	,
		true	,
		"automatically unbox arrays of doubles"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices DEFINE_bool	(	crankshaft	,
		true	,
		"use crankshaft"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter DEFINE_bool	(	use_gvn	,
		true	,
		"use hydrogen global value numbering"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations DEFINE_bool	(	use_canonicalizing	,
		true	,
		"use hydrogen instruction canonicalizing"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining DEFINE_bool	(	use_escape_analysis	,
		true	,
		"use hydrogen escape analysis"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding DEFINE_bool	(	use_local_allocation_folding	,
		false	,
		"only fold in basic blocks"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining DEFINE_bool	(	loop_invariant_code_motion	,
		true	,
		"loop invariant code motion"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache DEFINE_bool	(	hydrogen_stats	,
		false	,
		"print statistics for hydrogen"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase DEFINE_bool	(	trace_hydrogen	,
		false	,
		"trace generated hydrogen to file"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter DEFINE_bool	(	trace_hydrogen_stubs	,
		false	,
		"trace generated hydrogen for stubs"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions DEFINE_bool	(	trace_load_elimination	,
		false	,
		"trace load elimination"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination DEFINE_bool	(	trace_alloc	,
		false	,
		"trace register allocator"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions DEFINE_bool	(	trace_range	,
		false	,
		"trace range analysis"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering DEFINE_bool	(	trace_representation	,
		false	,
		"trace representation types"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis DEFINE_bool	(	trace_allocation_folding	,
		false	,
		"trace allocation folding"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites DEFINE_bool	(	trace_migration	,
		false	,
		"trace object migration"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization DEFINE_bool	(	stress_pointer_maps	,
		false	,
		"pointer map for every instruction"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections DEFINE_bool	(	print_deopt_stress	,
		false	,
		"print number of possible deopt points"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing DEFINE_bool	(	trap_on_stub_deopt	,
		false	,
		"put a break point before deoptimizing a stub"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases DEFINE_bool	(	polymorphic_inlining	,
		true	,
		"polymorphic inlining"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement DEFINE_bool	(	array_bounds_checks_elimination	,
		true	,
		"perform array bounds checks elimination"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination DEFINE_bool	(	array_bounds_checks_hoisting	,
		false	,
		"perform array bounds checks hoisting"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting DEFINE_bool	(	analyze_environment_liveness	,
		true	,
		"analyze liveness of environment slots and zap dead values"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination DEFINE_bool	(	check_elimination	,
		true	,
		"use check elimination"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination DEFINE_bool	(	dead_code_elimination	,
		true	,
		"use dead code elimination"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding DEFINE_bool	(	trace_dead_code_elimination	,
		false	,
		"trace dead code elimination"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code DEFINE_bool	(	trace_osr	,
		false	,
		"trace on-stack replacement"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs DEFINE_bool	(	optimize_closures	,
		true	,
		"optimize closures"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself DEFINE_bool	(	cache_optimized_code	,
		true	,
		"cache optimized code for closures"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC DEFINE_bool	(	inline_construct	,
		true	,
		"inline constructor calls"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object DEFINE_bool ( inline_accessors  , true  , "inline JavaScript accessors"    )

inline

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations DEFINE_bool	(	optimize_for_in	,
		true	,
		"optimize functions containing for-in loops"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations DEFINE_bool	(	concurrent_recompilation	,
		true	,
		"optimizing hot functions asynchronously on a separate thread"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms DEFINE_bool	(	block_concurrent_recompilation	,
		false	,
		"block queued jobs until released"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly DEFINE_bool	(	enable_sse2	,
		true	,
		"enable use of SSE2 instructions if available"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available DEFINE_bool	(	enable_sse4_1	,
		true	,
		"enable use of SSE4.1 instructions if available"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available DEFINE_bool	(	enable_sahf	,
		true	,
		"enable use of SAHF instruction if available (X64 only)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available DEFINE_bool	(	enable_armv7	,
		ENABLE_ARMV7_DEFAULT	,
		"enable use of ARMv7 instructions if available (ARM only)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 DEFINE_bool	(	enable_vldr_imm	,
		false	,
		"enable use of constant pools for double immediate (ARM only)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension DEFINE_bool	(	expose_gc	,
		false	,
		"expose gc extension"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension DEFINE_bool	(	expose_trigger_failure	,
		false	,
		"expose trigger-failure extension"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture DEFINE_bool	(	builtins_in_stack_traces	,
		false	,
		"show built-in functions in stack traces"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files DEFINE_bool	(	inline_new	,
		true	,
		"use fast inline allocation"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated DEFINE_bool	(	trace	,
		false	,
		"trace function calls"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants DEFINE_bool	(	lazy	,
		true	,
		"use lazy compilation"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization DEFINE_bool	(	trace_opt_stats	,
		false	,
		"trace lazy optimization statistics"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations DEFINE_bool	(	always_opt	,
		false	,
		"always try to optimize functions"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions DEFINE_bool	(	prepare_always_opt	,
		false	,
		"prepare for turning on always opt"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization DEFINE_bool	(	trace_stub_failures	,
		false	,
		"trace deoptimization of generated code stubs"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing DEFINE_bool	(	always_full_compiler	,
		false	,
		"try to use the dedicated run-once backend for all code"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up DEFINE_bool	(	compilation_cache	,
		true	,
		"enable compilation cache"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response DEFINE_bool	(	trace_js_array_abuse	,
		false	,
		"trace out-of-bounds accesses to JS arrays"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays DEFINE_bool	(	trace_array_abuse	,
		false	,
		"trace out-of-bounds accesses to all arrays"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue DEFINE_bool	(	enable_liveedit	,
		true	,
		"enable liveedit experimental feature"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace DEFINE_bool	(	always_inline_smi_code	,
		false	,
		"always inline smi code in non-opt code"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection DEFINE_bool	(	trace_gc_nvp	,
		false
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection DEFINE_bool	(	print_cumulative_gc_stat	,
		false
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers DEFINE_bool	(	log_colour	,
		true	,
		"When	logging,
		try to use coloured output."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros DEFINE_bool	(	trace_sim_messages	,
		false	,
		"Trace simulator debug messages. Implied by --trace-sim."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown DEFINE_bool	(	abort_on_uncaught_exception	,
		false	,
		"abort program (dump core) when an uncaught exception is thrown"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot DEFINE_bool	(	regexp_optimization	,
		true	,
		"generate optimized regexp code"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs DEFINE_bool	(	predictable	,
		false	,
		"enable predictable mode"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console DEFINE_bool	(	dump_counters	,
		false	,
		"Dump counters on exit"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events DEFINE_bool	(	debug_script_collected_events	,
		true	,
		"Enable debugger script collected events"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects DEFINE_bool	(	gdbjit_dump	,
		false	,
		"dump elf objects with debug info to disk"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring DEFINE_bool	(	force_marking_deque_overflows	,
		false	,
		"force overflows of marking deque by reducing it's size ""to 64 words"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code DEFINE_bool	(	print_builtin_source	,
		false	,
		"pretty print source code for builtins"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST DEFINE_bool	(	print_builtin_ast	,
		false	,
		"print source AST for builtins"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint DEFINE_bool	(	trap_on_abort	,
		false	,
		"replace aborts by breakpoints"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins DEFINE_bool	(	print_scopes	,
		false	,
		"print scopes"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations DEFINE_bool	(	gc_greedy	,
		false	,
		"perform GC prior to some allocations"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection DEFINE_bool	(	heap_stats	,
		false	,
		"report heap statistics before and after GC"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC DEFINE_bool	(	verify_native_context_separation	,
		false	,
		"verify that code holds on to at most one native context after GC"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC DEFINE_bool	(	print_global_handles	,
		false	,
		"report global handles after GC"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions DEFINE_bool ( print_interfaces  , false  , "print interfaces"    )

inline

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries DEFINE_bool	(	trace_lazy	,
		false	,
		"trace lazy compilation"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes DEFINE_bool	(	regexp_possessive_quantifier	,
		false	,
		"enable possessive quantifier syntax for testing"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution DEFINE_bool	(	trace_regexp_assembler	,
		false	,
		"trace regexp macro assembler calls."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file DEFINE_bool	(	log_runtime	,
		false	,
		"Activate runtime system %Log call."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file DEFINE_bool	(	log_code	,
		false	,
		"Log code events to the log file without profiling."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool DEFINE_bool	(	log_handles	,
		false	,
		"Log global handle events."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations DEFINE_bool	(	prof	,
		false	,
		"Log statistical profiling information (implies --log-code)."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling DEFINE_bool	(	log_regexp	,
		false	,
		"Log regular expression execution."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file DEFINE_bool	(	logfile_per_isolate	,
		true	,
		"Separate log files for each isolate."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler DEFINE_bool	(	perf_basic_prof	,
		false	,
		"Enable perf linux profiler (basic support)."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof DEFINE_bool	(	log_internal_timer_events	,
		false	,
		"Time internal events."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof DEFINE_bool	(	log_instruction_stats	,
		false	,
		"Log AArch64 instruction statistics."
	)

DEFINE_bool	(	trace_elements_transitions	,
		false	,
		"trace elements transitions"
	)

trace the creation of allocation sites DEFINE_bool	(	print_code_stubs	,
		false	,
		"print code stubs"
	)

trace the creation of allocation sites test secondary stub cache by disabling the primary one DEFINE_bool	(	test_primary_stub_cache	,
		false	,
		"test primary stub cache by disabling the secondary one"
	)

trace the creation of allocation sites test secondary stub cache by disabling the primary one print generated code DEFINE_bool	(	print_opt_code	,
		false	,
		"print optimized code"
	)

trace the creation of allocation sites test secondary stub cache by disabling the primary one print generated code print unoptimized code before printing optimized code based on it DEFINE_bool	(	print_code_verbose	,
		false	,
		"print more information for code"
	)

DEFINE_bool	(	enable_ool_constant_pool	,
		V8_OOL_CONSTANT_POOL	,
		"enable use of out-of-line constant pools (ARM only)"
	)

Definition at line 1829 of file flags.cc.

enforce strict mode v8::internal::DEFINE_bool	(	es_staging	,
		false	,
		"enable upcoming ES6+ features"
	)

enforce strict mode enable harmony semantics for typeof v8::internal::DEFINE_bool	(	harmony_scoping	,
		false	,
		"enable harmony block scoping"
	)

v8::internal::DEFINE_DOUBLE	(	kFP64PositiveInfinity	,
		0x7ff0000000000000UL
	)

v8::internal::DEFINE_DOUBLE	(	kFP64NegativeInfinity	,
		0xfff0000000000000UL
	)

v8::internal::DEFINE_DOUBLE	(	kFP64SignallingNaN	,
		0x7ff000007f800001
	)

v8::internal::DEFINE_DOUBLE	(	kFP64QuietNaN	,
		0x7ff800007fc00001
	)

v8::internal::DEFINE_DOUBLE	(	kFP64DefaultNaN	,
		0x7ff8000000000000UL
	)

v8::internal::DEFINE_FLOAT	(	kFP32PositiveInfinity	,
		0x7f800000
	)

v8::internal::DEFINE_FLOAT	(	kFP32NegativeInfinity	,
		0xff800000
	)

v8::internal::DEFINE_FLOAT	(	kFP32SignallingNaN	,
		0x7f800001
	)

v8::internal::DEFINE_FLOAT	(	kFP32QuietNaN	,
		0x7fc00001
	)

v8::internal::DEFINE_FLOAT	(	kFP32DefaultNaN	,
		0x7fc00000
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag DEFINE_float	(	testing_float_flag	,
		2.	5,
		"float-flag"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping DEFINE_implication	(	harmony	,
		harmony_modules
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols DEFINE_implication	(	harmony	,
		harmony_proxies
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections DEFINE_implication	(	harmony	,
		harmony_generators
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration DEFINE_implication	(	harmony	,
		harmony_numeric_literals
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings DEFINE_implication	(	harmony	,
		harmony_arrays
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping DEFINE_implication	(	harmony	,
		es_staging
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields DEFINE_implication	(	track_heap_object_fields	,
		track_fields
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement DEFINE_implication	(	concurrent_osr	,
		concurrent_recompilation
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing DEFINE_implication	(	trace_opt_verbose	,
		trace_opt
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name DEFINE_implication	(	expose_gc_as	,
		expose_gc
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse DEFINE_implication	(	trace_array_abuse	,
		trace_external_array_abuse
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks DEFINE_implication	(	log_timer_events	,
		log_internal_timer_events
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code DEFINE_int	(	max_inlining_levels	,
		5	,
		"maximum number of inlining levels"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining DEFINE_int	(	max_inlined_nodes	,
		196	,
		"maximum number of AST nodes considered for a single inlining"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction DEFINE_int	(	deopt_every_n_times	,
		0	,
		"deoptimize every n times a deopt point is passed"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation DEFINE_int	(	concurrent_recompilation_queue_length	,
		8	,
		"the length of the concurrent compilation queue"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes DEFINE_int	(	typed_array_max_size_in_heap	,
		64	,
		"threshold for in-heap typed array"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler DEFINE_int	(	interrupt_budget	,
		0x1800	,
		"execution budget before interrupt is triggered"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization DEFINE_int	(	self_opt_count	,
		130	,
		"call count before self-optimization"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions DEFINE_int	(	cpu_profiler_sampling_interval	,
		1000	,
		"CPU profiler sampling interval in microseconds"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing DEFINE_int	(	stack_size	,
		kPointerSize *	123,
		"default size of stack region v8 is allowed to use (in kBytes)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs DEFINE_int	(	gc_interval	,
		-	1,
		"garbage collect after <n> allocations"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag DEFINE_int	(	testing_prng_seed	,
		42	,
		"Seed used for threading test randomness"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details DEFINE_int	(	print_interface_depth	,
		5	,
		"depth for printing interfaces"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof arm64_inst AArch64 instruction statistics log file DEFINE_int	(	log_instruction_period	,
		1<<	22,
		"AArch64 instruction statistics logging period."
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag DEFINE_maybe_bool	(	testing_maybe_bool_flag	,
		"testing_maybe_bool_flag"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation DEFINE_neg_implication	(	predictable	,
		concurrent_osr
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping DEFINE_neg_implication	(	predictable	,
		parallel_sweeping
	)

v8::internal::DEFINE_NEW_H_BITWISE_INSTR	(	HSar	,
		c_left->	NumberValueAsInteger32) >>(c_right->NumberValueAsInteger32()&0x1f
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name DEFINE_string	(	trace_phase	,
		"HLZ"	,
		"trace generated IR for specified phases"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object DEFINE_string	(	expose_debug_as	,
		NULL	,
		"expose debug in global object"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap DEFINE_string	(	extra_code	,
		NULL	,
		"A filename with extra code to be included in"" the snapshot (mksnapshot only)"
	)

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof arm64_inst AArch64 instruction statistics log file output deopt information and disassembly into file code< pid >< isolateid > asm DEFINE_string	(	redirect_code_traces_to	,
		NULL	,
		"output deopt information and disassembly into the given file"
	)

void v8::internal::DeleteArray

(

T *

array

)

Definition at line 91 of file allocation.h.

Referenced by Log::Close(), Logger::DebugEvent(), StartupDataDecompressor::Decompress(), ArrayDeallocator< T >::Delete(), HandleScopeImplementer::DeleteExtensions(), Vector< const uint8_t >::Dispose(), SourceResource::Dispose(), DoubleToFixedCString(), RegExpStack::EnsureCapacity(), FormatMessage(), StringsStorage::GetVFormatted(), HeapStringAllocator::grow(), Snapshot::Initialize(), Parser::Parse(), ReadCharsFromFile(), ReadLine(), HandleScopeImplementer::ReturnBlock(), RUNTIME_FUNCTION(), V8HeapExplorer::TagGlobalObjects(), NewSpace::TearDown(), TEST(), THREADED_TEST(), AsciiResource::~AsciiResource(), AssemblerBase::~AssemblerBase(), BacktrackStack::~BacktrackStack(), CompilationSubCache::~CompilationSubCache(), ExternalReferenceDecoder::~ExternalReferenceDecoder(), HandleScopeImplementer::~HandleScopeImplementer(), HeapStringAllocator::~HeapStringAllocator(), OptimizingCompilerThread::~OptimizingCompilerThread(), Resource::~Resource(), ScopedVector< char >::~ScopedVector(), StartupDataDecompressor::~StartupDataDecompressor(), StringsStorage::~StringsStorage(), TestAsciiResource::~TestAsciiResource(), TestResource::~TestResource(), String::Utf8Value::~Utf8Value(), and String::Value::~Value().

void v8::internal::DeleteNativeObjectAt	(	const v8::WeakCallbackData< v8::Value, void > &	data,
		int	index
	)

Definition at line 869 of file i18n.cc.

References Handle< T >::Cast(), Object::GetAlignedPointerFromInternalField(), WeakCallbackData< T, P >::GetValue(), obj, and T.

Handle< Object > DeleteProperty	(	Handle< JSObject >	object,
		Handle< Object >	key
	)

Definition at line 170 of file handles.cc.

References CALL_HEAP_FUNCTION, Runtime::DeleteObjectProperty(), and JSReceiver::NORMAL_DELETION.

Referenced by Object::Delete().

uint64_t v8::internal::double_to_uint64 ( double  d )

inline

Definition at line 37 of file double.h.

Referenced by Object::GetHash(), and RUNTIME_FUNCTION().

void DoubleToAscii	(	double	v,
		DtoaMode	mode,
		int	requested_digits,
		Vector< char >	buffer,
		int *	sign,
		int *	length,
		int *	point
	)

Definition at line 56 of file dtoa.cc.

References ASSERT, BignumDtoa(), DTOA_FIXED, DTOA_PRECISION, DTOA_SHORTEST, FAST_DTOA_PRECISION, FAST_DTOA_SHORTEST, FastDtoa(), FastFixedDtoa(), and UNREACHABLE.

Referenced by DoubleToCString(), DoubleToExponentialCString(), DoubleToFixedCString(), DoubleToPrecisionCString(), and TEST().

const char * DoubleToCString	(	double	v,
		Vector< char >	buffer
	)

Definition at line 81 of file conversions.cc.

References DoubleToAscii(), DTOA_SHORTEST, FP_INFINITE, FP_NAN, FP_ZERO, std::fpclassify(), kBase10MaximalLength, Vector< T >::length(), sign, and Vector< T >::start().

Referenced by DuplicateFinder::AddNumber(), DoubleToFixedCString(), IntToCString(), and Heap::NumberToString().

char * DoubleToExponentialCString	(	double	value,
		int	f
	)

Definition at line 260 of file conversions.cc.

References ASSERT, DoubleToAscii(), DTOA_PRECISION, DTOA_SHORTEST, kBase10MaximalLength, and sign.

Referenced by RUNTIME_FUNCTION().

char * DoubleToFixedCString	(	double	value,
		int	f
	)

Definition at line 156 of file conversions.cc.

References SimpleStringBuilder::AddCharacter(), SimpleStringBuilder::AddPadding(), SimpleStringBuilder::AddString(), SimpleStringBuilder::AddSubstring(), ARRAY_SIZE, ASSERT, DeleteArray(), DoubleToAscii(), DoubleToCString(), DTOA_FIXED, SimpleStringBuilder::Finalize(), negative, sign, and StrDup().

Referenced by RUNTIME_FUNCTION().

int32_t DoubleToInt32 ( double  x )

inline

Definition at line 95 of file conversions-inl.h.

References Double::Exponent(), FastD2I(), FastI2D(), Double::kSignificandSize, Double::Sign(), and Double::Significand().

Referenced by ParserTraits::BuildUnaryExpression(), CheckArrayAbuse(), DataViewConvertValue< int16_t >(), DataViewConvertValue< int32_t >(), DataViewConvertValue< int8_t >(), DoubleToUint32(), FixedTypedArray< Traits >::from_double(), NumberToInt32(), RUNTIME_FUNCTION(), and ParserTraits::ShortcutNumericLiteralBinaryExpression().

double DoubleToInteger ( double  x )

inline

Definition at line 88 of file conversions-inl.h.

References std::isfinite(), and std::isnan().

Referenced by RUNTIME_FUNCTION().

char * DoubleToPrecisionCString	(	double	value,
		int	p
	)

Definition at line 305 of file conversions.cc.

References SimpleStringBuilder::AddCharacter(), SimpleStringBuilder::AddPadding(), SimpleStringBuilder::AddString(), SimpleStringBuilder::AddSubstring(), ASSERT, DoubleToAscii(), DTOA_PRECISION, SimpleStringBuilder::Finalize(), Min(), NULL, SimpleStringBuilder::position(), sign, StrLength(), and USE().

Referenced by RUNTIME_FUNCTION().

char * DoubleToRadixCString	(	double	value,
		int	radix
	)

Definition at line 375 of file conversions.cc.

References SimpleStringBuilder::AddCharacter(), SimpleStringBuilder::AddSubstring(), ASSERT, and SimpleStringBuilder::Finalize().

Referenced by RUNTIME_FUNCTION().

uint32_t v8::internal::DoubleToUint32 ( double  x )

inline

Definition at line 106 of file conversions.h.

References DoubleToInt32().

Referenced by DataViewConvertValue< uint16_t >(), DataViewConvertValue< uint32_t >(), DataViewConvertValue< uint8_t >(), NumberToUint32(), ExternalUint32Array::SetValue(), and ParserTraits::ShortcutNumericLiteralBinaryExpression().

void DumpBacktrace

(

)

Definition at line 47 of file checks.cc.

References ARRAY_SIZE, NULL, OS::PrintError(), size, and symbols().

Referenced by V8_Fatal().

typedef v8::internal::DWORD

(

__stdcall *

DLL_FUNC_TYPESymGetOptions

)

Referenced by OS::Guard(), OS::ProtectCode(), and Win32Time::SetToCurrentTime().

typedef v8::internal::DWORD

(

__stdcall *

DLL_FUNC_TYPESymSetOptions

)

typedef v8::internal::DWORD64

(

__stdcall *

DLL_FUNC_TYPESymLoadModule64

)

typedef v8::internal::DWORD64

(

__stdcall *

DLL_FUNC_TYPESymGetModuleBase64

)

int ElementsKindToShiftSize

(

ElementsKind

elements_kind

)

Definition at line 38 of file elements-kind.cc.

References DICTIONARY_ELEMENTS, EXTERNAL_FLOAT32_ELEMENTS, EXTERNAL_FLOAT64_ELEMENTS, EXTERNAL_INT16_ELEMENTS, EXTERNAL_INT32_ELEMENTS, EXTERNAL_INT8_ELEMENTS, EXTERNAL_UINT16_ELEMENTS, EXTERNAL_UINT32_ELEMENTS, EXTERNAL_UINT8_CLAMPED_ELEMENTS, EXTERNAL_UINT8_ELEMENTS, FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, FAST_SMI_ELEMENTS, FLOAT32_ELEMENTS, FLOAT64_ELEMENTS, INT16_ELEMENTS, INT32_ELEMENTS, INT8_ELEMENTS, kPointerSizeLog2, SLOPPY_ARGUMENTS_ELEMENTS, UINT16_ELEMENTS, UINT32_ELEMENTS, UINT8_CLAMPED_ELEMENTS, UINT8_ELEMENTS, and UNREACHABLE.

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::MaxIndexOffsetBits().

const char * ElementsKindToString

(

ElementsKind

kind

)

Definition at line 77 of file elements-kind.cc.

References ElementsAccessor::ForKind(), and ElementsAccessor::name().

Referenced by ArrayConstructorStubBase::BasePrintName(), AllocationSite::DigestTransitionFeedback(), and PrintElementsKind().

int v8::internal::EncodeConstantPoolLength ( int  length )

inline

Definition at line 44 of file constants-arm.h.

References ASSERT, and kConstantPoolLengthMaxMask.

bool EvalComparison	(	Token::Value	op,
		double	op1,
		double	op2
	)

Definition at line 1516 of file assembler.cc.

References ASSERT, EQ, Token::IsCompareOp(), and UNREACHABLE.

double v8::internal::fast_exp

(

double

input

)

Referenced by RUNTIME_FUNCTION().

double v8::internal::fast_sqrt

(

double

input

)

Referenced by power_helper(), and RUNTIME_FUNCTION().

int v8::internal::FastD2I ( double  x )

inline

Definition at line 74 of file conversions.h.

Referenced by DoubleToInt32(), Heap::NumberFromDouble(), RUNTIME_FUNCTION(), TEST(), Object::ToInt32(), and Object::ToSmi().

int v8::internal::FastD2IChecked ( double  x )

inline

Definition at line 63 of file conversions.h.

Referenced by RUNTIME_FUNCTION(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::SetLengthWithoutNormalize(), and TEST().

unsigned int FastD2UI ( double  x )

inline

Definition at line 62 of file conversions-inl.h.

References OS::MemCopy(), and negative.

Referenced by CheckArrayAbuse(), Value::IsUint32(), and Object::ToUint32().

bool FastDtoa	(	double	v,
		FastDtoaMode	mode,
		int	requested_digits,
		Vector< char >	buffer,
		int *	length,
		int *	decimal_point
	)

Definition at line 709 of file fast-dtoa.cc.

References ASSERT, FAST_DTOA_PRECISION, FAST_DTOA_SHORTEST, and UNREACHABLE.

Referenced by DoubleToAscii(), and TEST().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining faster

(

but maybe less

accurate

)

bool FastFixedDtoa	(	double	v,
		int	fractional_count,
		Vector< char >	buffer,
		int *	length,
		int *	decimal_point
	)

Definition at line 312 of file fixed-dtoa.cc.

References ASSERT, Double::Exponent(), kMaxUInt32, Double::Significand(), and V8_2PART_UINT64_C.

Referenced by DoubleToAscii(), and TEST().

double v8::internal::FastI2D ( int  x )

inline

Definition at line 81 of file conversions.h.

Referenced by CheckArrayAbuse(), DoubleToInt32(), Heap::NumberFromInt32(), RUNTIME_FUNCTION(), Object::ToInt32(), and Object::ToSmi().

ElementsKind v8::internal::FastSmiToObjectElementsKind ( ElementsKind  from_kind )

inline

Definition at line 234 of file elements-kind.h.

References ASSERT, FAST_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_SMI_ELEMENTS, and IsFastSmiElementsKind().

Referenced by JSObject::ResetElements().

double v8::internal::FastUI2D ( unsigned  x )

inline

Definition at line 89 of file conversions.h.

Referenced by Value::IsUint32(), Heap::NumberFromUint32(), and Object::ToUint32().

void v8::internal::FatalProcessOutOfMemory

(

const char *

message

)

Referenced by AlignedAlloc(), Malloced::FatalProcessOutOfMemory(), Isolate::Init(), and Malloced::New().

MemOperand FieldMemOperand ( Register  object, int  offset  )

inline

Definition at line 42 of file macro-assembler-arm.h.

References kHeapObjectTag.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), LCodeGen::DoDeferredTaggedToI(), MacroAssembler::IsInstanceJSObjectType(), MacroAssembler::IsObjectJSObjectType(), MacroAssembler::IsObjectJSStringType(), and MacroAssembler::IsObjectStringType().

Operand FieldOperand ( Register  object, int  offset  )

inline

Definition at line 1075 of file macro-assembler-ia32.h.

References kHeapObjectTag.

Referenced by FixedArrayElementOperand().

Operand FieldOperand ( Register  object, Register  index, ScaleFactor  scale, int  offset  )

inline

Definition at line 1081 of file macro-assembler-ia32.h.

References kHeapObjectTag.

void v8::internal::FindAsciiStringIndices	(	Vector< const uint8_t >	subject,
		char	pattern,
		ZoneList< int > *	indices,
		unsigned int	limit,
		Zone *	zone
	)

Definition at line 3819 of file runtime.cc.

References List< T, P >::Add(), ASSERT, Vector< T >::length(), NULL, and Vector< T >::start().

Referenced by FindStringIndicesDispatch().

void v8::internal::FindStringIndices	(	Isolate *	isolate,
		Vector< const SubjectChar >	subject,
		Vector< const PatternChar >	pattern,
		ZoneList< int > *	indices,
		unsigned int	limit,
		Zone *	zone
	)

Definition at line 3859 of file runtime.cc.

References List< T, P >::Add(), ASSERT, Vector< T >::length(), and StringSearch< PatternChar, SubjectChar >::Search().

Referenced by FindStringIndicesDispatch().

void v8::internal::FindStringIndicesDispatch	(	Isolate *	isolate,
		String *	subject,
		String *	pattern,
		ZoneList< int > *	indices,
		unsigned int	limit,
		Zone *	zone
	)

Definition at line 3881 of file runtime.cc.

References ASSERT, FindAsciiStringIndices(), FindStringIndices(), FindTwoByteStringIndices(), String::GetFlatContent(), String::FlatContent::IsAscii(), String::FlatContent::IsFlat(), Vector< T >::length(), String::FlatContent::ToOneByteVector(), and String::FlatContent::ToUC16Vector().

Referenced by RUNTIME_FUNCTION().

void v8::internal::FindTwoByteStringIndices	(	const Vector< const uc16 >	subject,
		uc16	pattern,
		ZoneList< int > *	indices,
		unsigned int	limit,
		Zone *	zone
	)

Definition at line 3841 of file runtime.cc.

References List< T, P >::Add(), ASSERT, Vector< T >::length(), and Vector< T >::start().

Referenced by FindStringIndicesDispatch().

Operand v8::internal::FixedArrayElementOperand ( Register  array, Register  index_as_smi, int  additional_offset = 0  )

inline

Definition at line 1089 of file macro-assembler-ia32.h.

References FieldOperand(), FixedArrayBase::kHeaderSize, kPointerSize, and times_half_pointer_size.

Handle< String > FlattenGetString

(

Handle< String >

string

)

Definition at line 156 of file handles.cc.

References CALL_HEAP_FUNCTION.

Referenced by CalculateLineEnds(), RegExpImpl::Compile(), Factory::NewProperSubString(), JSON::Parse(), RUNTIME_FUNCTION(), THREADED_TEST(), and String::WriteUtf8().

void FlattenString

(

Handle< String >

string

)

Definition at line 151 of file handles.cc.

References CALL_HEAP_FUNCTION_VOID.

Referenced by RegExpImpl::AtomExecRaw(), RegExpEngine::Compile(), MessageHandler::GetMessage(), GetUtf8Length(), RegExpImpl::IrregexpPrepare(), RUNTIME_FUNCTION(), JSObject::SetAccessor(), Runtime::StringMatch(), TEST(), TestStringCharacterStream(), THREADED_TEST(), and String::WriteUtf8().

void v8::internal::FlipBytes ( uint8_t *  target, uint8_t *  source  )

inline

Definition at line 1317 of file runtime.cc.

void Flush

(

FILE *

out

)

Definition at line 65 of file v8utils.cc.

Referenced by Flush(), and RUNTIME_FUNCTION().

void v8::internal::Flush ( )

inline

Definition at line 66 of file v8utils.h.

References Flush().

Handle< Object > ForceDeleteProperty	(	Handle< JSObject >	object,
		Handle< Object >	key
	)

Definition at line 179 of file handles.cc.

References CALL_HEAP_FUNCTION, Runtime::DeleteObjectProperty(), and JSReceiver::FORCE_DELETION.

Referenced by Object::ForceDelete().

Handle< Object > ForceSetProperty	(	Handle< JSObject >	object,
		Handle< Object >	key,
		Handle< Object >	value,
		PropertyAttributes	attributes
	)

Definition at line 161 of file handles.cc.

References Runtime::ForceSetObjectProperty().

Referenced by Object::ForceSet(), and RUNTIME_FUNCTION().

F v8::internal::FUNCTION_CAST

(

Address

addr

)

Definition at line 352 of file globals.h.

References F.

double v8::internal::FusedMultiplyAdd ( double  op1, double  op2, double  a  )

inline

Definition at line 124 of file utils-arm64.h.

float v8::internal::FusedMultiplyAdd ( float  op1, float  op2, float  a  )

inline

Definition at line 129 of file utils-arm64.h.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old generation

(

in

kBytes

)

Referenced by CompilationSubCache::GetTable(), CompilationCacheScript::Lookup(), CompilationCacheEval::Lookup(), CompilationCacheRegExp::Lookup(), and CompilationSubCache::Remove().

Register v8::internal::GetAllocatableRegisterThatIsNotOneOf	(	Register	reg1,
		Register	reg2 = NoReg,
		Register	reg3 = NoReg,
		Register	reg4 = NoReg
	)

const char * GetBailoutReason

(

BailoutReason

reason

)

Definition at line 16437 of file objects.cc.

References ASSERT, ERROR_MESSAGES_LIST, ERROR_MESSAGES_TEXTS, and kLastErrorMessage.

Referenced by CpuProfiler::CodeCreateEvent(), SharedFunctionInfo::DisableOptimization(), Compiler::GetOptimizedCode(), and RUNTIME_FUNCTION().

Vector< const uint8_t > GetCharVector

(

Handle< String >

string

)

Definition at line 46 of file uri.h.

References ASSERT, String::FlatContent::IsAscii(), and String::FlatContent::ToOneByteVector().

Vector< const uc16 > GetCharVector

(

Handle< String >

string

)

Definition at line 54 of file uri.h.

References ASSERT, String::FlatContent::IsTwoByte(), and String::FlatContent::ToUC16Vector().

Handle< FixedArray > GetEnumPropertyKeys	(	Handle< JSObject >	object,
		bool	cache_result
	)

Definition at line 626 of file handles.cc.

References ALL_DESCRIPTORS, ASSERT, Object::cast(), Isolate::counters(), DONT_SHOW, Isolate::factory(), FIELD, Smi::FromInt(), DescriptorArray::GetEnumCache(), Isolate::heap(), Handle< T >::is_null(), DescriptorArray::kEnumCacheBridgeLength, keys(), map, HeapObject::map(), Factory::NewFixedArray(), OWN_DESCRIPTORS, ReduceFixedArrayTo(), and DescriptorArray::SetEnumCache().

Referenced by GetKeysInFixedArrayFor().

ElementsKind GetFastElementsKindFromSequenceIndex

(

int

sequence_number

)

Definition at line 127 of file elements-kind.cc.

References ASSERT, and kFastElementsKindCount.

Referenced by GetNextTransitionElementsKind().

ElementsKind v8::internal::GetHoleyElementsKind ( ElementsKind  packed_kind )

inline

Definition at line 220 of file elements-kind.h.

References FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by ArrayConstructInitializeElements(), BUILTIN(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::DeleteCommon(), AllocationSite::DigestTransitionFeedback(), JSObject::EnsureCanContainElements(), IsSimpleMapChangeTransition(), Factory::NewJSArray(), JSObject::SetFastElement(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::SetLengthWithoutNormalize(), and JSObject::TransitionElementsKind().

ElementsKind GetInitialFastElementsKind

(

)

Definition at line 88 of file elements-kind.cc.

References FAST_HOLEY_SMI_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by CodeStubGraphBuilder< Stub >::BuildCodeStub(), BUILTIN(), AllocationSite::Initialize(), ArrayConstructorStubBase::InstallDescriptors(), Isolate::IsFastArrayConstructorPrototypeChainIntact(), Factory::NewFunctionWithPrototype(), and JSObject::ResetElements().

Handle< JSArray > GetKeysFor	(	Handle< JSReceiver >	object,
		bool *	threw
	)

Definition at line 606 of file handles.cc.

References Isolate::counters(), Isolate::factory(), GetKeysInFixedArrayFor(), INCLUDE_PROTOS, and Factory::NewJSArrayWithElements().

Referenced by RUNTIME_FUNCTION().

v8::Handle< v8::Array > GetKeysForIndexedInterceptor	(	Handle< JSReceiver >	receiver,
		Handle< JSObject >	object
	)

Definition at line 452 of file handles.cc.

References CHECK, LOG, Local< T >::New(), and Utils::OpenHandle().

Referenced by GetKeysInFixedArrayFor(), and RUNTIME_FUNCTION().

v8::Handle< v8::Array > GetKeysForNamedInterceptor	(	Handle< JSReceiver >	receiver,
		Handle< JSObject >	object
	)

Definition at line 429 of file handles.cc.

References CHECK, LOG, Local< T >::New(), and Utils::OpenHandle().

Referenced by GetKeysInFixedArrayFor(), and RUNTIME_FUNCTION().

Handle< FixedArray > GetKeysInFixedArrayFor	(	Handle< JSReceiver >	object,
		KeyCollectionType	type,
		bool *	threw
	)

Definition at line 505 of file handles.cc.

References v8::ACCESS_KEYS, AddKeysFromJSArray(), ARRAY_SIZE, ASSERT, Execution::Call(), JSObject::cast(), JSFunction::cast(), JSProxy::cast(), Isolate::context(), Isolate::factory(), GetEnumPropertyKeys(), GetKeysForIndexedInterceptor(), GetKeysForNamedInterceptor(), Isolate::has_scheduled_exception(), Isolate::heap(), Handle< T >::IsEmpty(), LOCAL_ONLY, Isolate::MayNamedAccessWrapper(), Context::native_context(), Factory::NewFixedArray(), Utils::OpenHandle(), Isolate::PromoteScheduledException(), Isolate::ReportFailedAccessCheckWrapper(), UnionOfKeys(), and USE().

Referenced by GetKeysFor(), Object::GetOwnPropertyNames(), Object::GetPropertyNames(), and RUNTIME_FUNCTION().

size_t v8::internal::GetMemoryUsedByList

(

const List< T, P > &

list

)

Definition at line 205 of file list.h.

References T.

Referenced by HeapProfiler::GetMemorySizeUsedByProfiler(), HeapObjectsMap::GetUsedMemorySize(), and HeapSnapshot::RawSnapshotSize().

ElementsKind GetNextMoreGeneralFastElementsKind	(	ElementsKind	elements_kind,
		bool	allow_only_packed
	)

Definition at line 160 of file elements-kind.cc.

References ASSERT, GetNextTransitionElementsKind(), IsFastElementsKind(), IsFastHoleyElementsKind(), TERMINAL_FAST_ELEMENTS_KIND, and UNREACHABLE.

Referenced by Map::FindTransitionedMap().

ElementsKind GetNextTransitionElementsKind

(

ElementsKind

kind

)

Definition at line 145 of file elements-kind.cc.

References FIXED_TYPED_ARRAY_CASE, GetFastElementsKindFromSequenceIndex(), GetSequenceIndexFromFastElementsKind(), and TYPED_ARRAYS.

Referenced by GetNextMoreGeneralFastElementsKind().

ElementsKind v8::internal::GetPackedElementsKind ( ElementsKind  holey_kind )

inline

Definition at line 206 of file elements-kind.h.

References FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by BUILTIN(), and RUNTIME_FUNCTION().

Handle< Object > GetProperty	(	Handle< JSReceiver >	obj,
		const char *	name
	)

Definition at line 196 of file handles.cc.

References CALL_HEAP_FUNCTION, Isolate::factory(), Factory::InternalizeUtf8String(), and Object.

Referenced by JSProxy::CallTrap(), Execution::CharAt(), FormatMessage(), Object::Get(), StackFrame::GetColumn(), StackFrame::GetFunctionName(), StackFrame::GetLineNumber(), JSProxy::GetPropertyAttributeWithHandler(), StackFrame::GetScriptId(), StackFrame::GetScriptName(), GetScriptNameOrSourceURL(), StackFrame::GetScriptNameOrSourceURL(), StackFrame::IsConstructor(), StackFrame::IsEval(), JSProxy::SetPropertyViaPrototypesWithHandler(), Isolate::StackOverflow(), TryCatch::StackTrace(), TEST(), and TestParserSyncWithFlags().

Handle< Object > GetProperty	(	Isolate *	isolate,
		Handle< Object >	obj,
		Handle< Object >	key
	)

Definition at line 204 of file handles.cc.

References CALL_HEAP_FUNCTION, and Runtime::GetObjectProperty().

Register GetRegisterThatIsNotOneOf	(	Register	reg1,
		Register	reg2 = no_reg,
		Register	reg3 = no_reg,
		Register	reg4 = no_reg,
		Register	reg5 = no_reg,
		Register	reg6 = no_reg
	)

int GetScriptColumnNumber	(	Handle< Script >	script,
		int	code_pos
	)

Definition at line 389 of file handles.cc.

References Smi::cast(), FixedArray::cast(), FixedArray::get(), and GetScriptLineNumber().

Referenced by Function::GetScriptColumnNumber(), Logger::LogExistingFunction(), and Compiler::RecordFunctionCompilation().

int GetScriptLineNumber	(	Handle< Script >	script,
		int	code_pos
	)

Definition at line 363 of file handles.cc.

References Smi::cast(), FixedArray::cast(), FixedArray::get(), InitScriptLineEnds(), and FixedArrayBase::length().

Referenced by Isolate::CaptureCurrentStackTrace(), UnboundScript::GetLineNumber(), GetScriptColumnNumber(), Function::GetScriptLineNumber(), GetScriptLineNumberSafe(), Logger::LogExistingFunction(), Compiler::RecordFunctionCompilation(), and TEST().

int GetScriptLineNumberSafe	(	Handle< Script >	script,
		int	code_pos
	)

Definition at line 403 of file handles.cc.

References String::cast(), GetScriptLineNumber(), and String::length().

Referenced by Isolate::DoThrow(), JavaScriptFrame::Print(), and JavaScriptFrame::PrintTop().

Handle< Object > GetScriptNameOrSourceURL

(

Handle< Script >

script

)

Definition at line 474 of file handles.cc.

References ASSERT, Handle< T >::cast(), Isolate::factory(), GetProperty(), GetScriptWrapper(), Factory::InternalizeOneByteString(), NULL, STATIC_ASCII_VECTOR, and Execution::TryCall().

Referenced by Isolate::CaptureCurrentStackTrace(), and Function::GetScriptOrigin().

Handle< JSValue > GetScriptWrapper

(

Handle< Script >

script

)

Definition at line 240 of file handles.cc.

References Handle< T >::cast(), Isolate::counters(), GlobalHandles::Create(), Isolate::factory(), Isolate::global_handles(), handle(), GlobalHandles::MakeWeak(), Factory::NewJSObject(), and NULL.

Referenced by GetScriptNameOrSourceURL(), MessageHandler::MakeMessageObject(), and RUNTIME_FUNCTION().

int GetSequenceIndexFromFastElementsKind

(

ElementsKind

elements_kind

)

Definition at line 134 of file elements-kind.cc.

References kFastElementsKindCount, and UNREACHABLE.

Referenced by GetNextTransitionElementsKind().

MemOperand v8::internal::GlobalObjectMemOperand ( )

inline

Definition at line 2245 of file macro-assembler-arm64.h.

References ContextMemOperand(), cp, and Context::GLOBAL_OBJECT_INDEX.

Operand GlobalObjectOperand ( )

inline

Definition at line 1592 of file macro-assembler-arm.h.

References ContextOperand(), cp, and Context::GLOBAL_OBJECT_INDEX.

Handle<T> v8::internal::handle ( T *  t, Isolate *  isolate  )

inline

Definition at line 103 of file handles.h.

Referenced by HeapTypeConfig::as_class(), HeapTypeConfig::as_constant(), HeapTypeConfig::as_union(), TypeFeedbackOracle::BinaryType(), ArrayBufferView::Buffer(), HGraphBuilder::BuildCheckPrototypeMaps(), HGraphBuilder::BuildConstantMapCheck(), HGraphBuilder::BuildWrapReceiver(), BUILTIN(), Promise::Catch(), Promise::Chain(), TypeImpl< ZoneTypeConfig >::Classes(), TypeFeedbackOracle::CollectReceiverTypes(), TypeFeedbackOracle::CompareType(), LoadIC::CompileHandler(), StoreIC::CompileHandler(), StoreStubCompiler::CompileStoreCallback(), IC::ComputeHandler(), StubCache::ComputeLoadNonexistent(), TypeImpl< ZoneTypeConfig >::Constants(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::CopyElements(), Map::CopyInstallDescriptors(), V8_FINAL< kOperandKind, kNumCachedOperands >::CreateImmovable(), Map::CurrentMapForDeprecatedInternal(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::DeleteCommon(), AllocationSite::DigestTransitionFeedback(), JSObject::EnqueueChangeRecord(), JSFunction::EnsureHasInitialMap(), JSGlobalObject::EnsurePropertyCell(), JSArray::EnsureSize(), Handle< T >::EscapeFrom(), Code::FindAllMaps(), JSObject::Freeze(), HeapTypeConfig::from_bitset(), JSObject::GeneralizeFieldRepresentation(), NormalizedMapCache::Get(), JSObject::GetAccessor(), IC::GetCodeCacheHolder(), Object::GetProperty(), JSObject::GetPropertyWithInterceptor(), CustomArguments< T >::GetReturnValue(), GetScriptWrapper(), HeapTypeConfig::handle(), LoadStubCompiler::HandlerFrontendHeader(), V8_FINAL< kOperandKind, kNumCachedOperands >::HasMap(), IC::IC(), FunctionTemplate::InstanceTemplate(), Value::IsPromise(), Deoptimizer::MaterializeHeapObjects(), JSObject::MigrateToMap(), Runtime::NeuterArrayBuffer(), Promise::Resolver::New(), Factory::NewFunctionPrototype(), LoadStubCompiler::NonexistentHandlerFrontend(), JSObject::NormalizeElements(), TypeImpl< class >::OfCurrently(), JSObject::PrepareElementsForSort(), JSObject::PreventExtensions(), Promise::Resolver::Reject(), Promise::Resolver::Resolve(), RUNTIME_FUNCTION(), JSObject::SetElement(), JSObject::SetFastElement(), JSObject::SetFastElementsCapacityAndLength(), JSFunction::SetInstancePrototype(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::SetLength(), JSObject::SetLocalPropertyIgnoreAttributes(), JSObject::SetObserved(), JSObject::SetPropertyForResult(), JSObject::SetPrototype(), JSFunction::SetPrototype(), TEST(), THREADED_TEST(), BASE_EMBEDDED< Visitor >::ToHandle(), Object::ToSmi(), BinaryOpIC::Transition(), V8_FINAL< kOperandKind, kNumCachedOperands >::transition_map(), Types< Type, TypeHandle, Region >::Types(), IC::TypeToMap(), HeapTypeConfig::union_get(), V8_FINAL< kOperandKind, kNumCachedOperands >::Unique(), IC::UpdateState(), IC::UpdateTarget(), and Visitor42::VisitPersistentHandle().

Handle<T> v8::internal::handle ( T *  t )

inline

Definition at line 110 of file handles.h.

typedef v8::internal::HANDLE

(

__stdcall *

DLL_FUNC_TYPECreateToolhelp32Snapshot

)

int v8::internal::HandleObjectPointerCompare	(	const Handle< T > *	a,
		const Handle< T > *	b
	)

Definition at line 182 of file utils.h.

Vector< Handle<Object> > v8::internal::HandleVector ( v8::internal::Handle< T > *  elms, int  length  )

inline

Definition at line 118 of file v8utils.h.

Referenced by JSProxy::CallTrap(), DictionaryElementsAccessor::DeleteCommon(), JSObject::Freeze(), Runtime::GetObjectProperty(), JSProxy::GetPropertyAttributeWithHandler(), JSObject::GetPropertyWithCallback(), JSObject::PreventExtensions(), IC::ReferenceError(), RUNTIME_FUNCTION(), JSObject::SetElement(), Runtime::SetObjectProperty(), JSObject::SetPropertyForResult(), JSProxy::SetPropertyViaPrototypesWithHandler(), JSObject::SetPropertyWithCallback(), JSObject::SetPrototype(), and IC::TypeError().

Handle< Object > HasProperty	(	Handle< JSReceiver >	obj,
		Handle< Object >	key
	)

Definition at line 189 of file handles.cc.

References CALL_HEAP_FUNCTION, and Runtime::HasObjectProperty().

Referenced by Object::Has().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with heap_stats

(

requires

heap_stats

)

intptr_t HeapObjectTagMask

(

)

Definition at line 44 of file checks.cc.

References kHeapObjectTagMask.

Referenced by AllocationInfo::INLINE().

void v8::internal::HeapSortPairs	(	FixedArray *	content,
		FixedArray *	numbers,
		int	len
	)

Definition at line 13342 of file objects.cc.

References ASSERT, FixedArray::get(), FixedArrayBase::length(), NumberToUint32(), and FixedArray::SwapPairs().

Referenced by FixedArray::SortPairs().

int v8::internal::HexValue ( uc32  c )

inline

Definition at line 52 of file scanner.h.

v8::internal::INITIALIZE_REGISTER	(	Register	,
		NoReg	,
		0	,
		0	,
		CPURegister::kNoRegister
	)

v8::internal::INITIALIZE_REGISTER	(	FPRegister	,
		NoFPReg	,
		0	,
		0	,
		CPURegister::kNoRegister
	)

v8::internal::INITIALIZE_REGISTER	(	CPURegister	,
		NoCPUReg	,
		0	,
		0	,
		CPURegister::kNoRegister
	)

v8::internal::INITIALIZE_REGISTER	(	Register	,
		no_reg	,
		0	,
		0	,
		CPURegister::kNoRegister
	)

v8::internal::INITIALIZE_REGISTER	(	Register	,
		wcsp	,
		kSPRegInternalCode	,
		kWRegSizeInBits	,
		CPURegister::kRegister
	)

v8::internal::INITIALIZE_REGISTER	(	Register	,
		csp	,
		kSPRegInternalCode	,
		kXRegSizeInBits	,
		CPURegister::kRegister
	)

bool InitializeICU

(

const char *

icu_data_file

)

Definition at line 64 of file icu_util.cc.

References NULL, and size.

Referenced by V8::InitializeICU().

void InitScriptLineEnds

(

Handle< Script >

script

)

Definition at line 278 of file handles.cc.

References ASSERT, String::cast(), Isolate::factory(), Isolate::heap(), and Factory::NewFixedArray().

Referenced by GetScriptLineNumber().

v8::internal::INLINE

(

static void

CopyCharsUnsignedsinkchar *dest, const sourcechar *src, int chars

)

v8::internal::INLINE

(

void

CopyCharssinkchar *dest, const sourcechar *src, int chars

)

v8::internal::INLINE

(

Dest

BitCastconst Source &source

)

v8::internal::INLINE

(

static HeapObject *

EnsureDoubleAlignedHeap *heap, HeapObject *object, int size

)

int IntegerLog2 ( uint32_t  value )

inline

Definition at line 62 of file misc-intrinsics.h.

References shift.

Referenced by RUNTIME_FUNCTION().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT interface

(

disables compacting

GC

)

Referenced by Interface::Add(), ParserTraits::ExpressionFromIdentifier(), and BASE_EMBEDDED< Visitor >::NewVariableProxy().

double v8::internal::InternalStringToDouble	(	UnicodeCache *	unicode_cache,
		Iterator	current,
		EndMark	end,
		int	flags,
		double	empty_string_val
	)

Definition at line 434 of file conversions-inl.h.

References AdvanceToNonspace(), ALLOW_BINARY, ALLOW_HEX, ALLOW_IMPLICIT_OCTAL, ALLOW_OCTAL, ALLOW_TRAILING_JUNK, ASSERT, isBinaryDigit(), isDigit(), JunkStringValue(), kMaxSignificantDigits, NONE, sign, SignedZero(), SLOW_ASSERT, Strtod(), SubStringEquals(), and V8_INFINITY.

Referenced by StringToDouble().

double v8::internal::InternalStringToInt	(	UnicodeCache *	unicode_cache,
		Iterator	current,
		EndMark	end,
		int	radix
	)

Definition at line 241 of file conversions-inl.h.

References AdvanceToNonspace(), ASSERT, isDigit(), IsPowerOf2(), JunkStringValue(), kMaxSignificantDigits, negative, SignedZero(), SLOW_ASSERT, Strtod(), U, and UNREACHABLE.

Referenced by StringToInt().

double v8::internal::InternalStringToIntDouble	(	UnicodeCache *	unicode_cache,
		Iterator	current,
		EndMark	end,
		bool	negative,
		bool	allow_trailing_junk
	)

Definition at line 140 of file conversions-inl.h.

References AdvanceToNonspace(), ASSERT, isDigit(), JunkStringValue(), overflow, and SignedZero().

const char * IntToCString	(	int	n,
		Vector< char >	buffer
	)

Definition at line 136 of file conversions.cc.

References DoubleToCString(), kMinInt, Vector< T >::length(), negative, and Vector< T >::start().

Referenced by Heap::NumberToString().

V8_INLINE internal::Object* v8::internal::IntToSmi

(

int

value

)

Definition at line 5485 of file v8.h.

References kSmiShiftSize, kSmiTag, and kSmiTagSize.

Referenced by Internals::IntToSmi(), and ReturnValue< T >::Set().

BranchType v8::internal::InvertBranchType ( BranchType  type )

inline

Definition at line 105 of file macro-assembler-arm64.h.

References InvertCondition(), kBranchTypeFirstCondition, and kBranchTypeLastCondition.

Condition v8::internal::InvertCondition ( Condition  cond )

inline

Definition at line 281 of file constants-arm64.h.

References al, ASSERT, and nv.

Referenced by BranchOnCondition::EmitInverted(), CompareAndBranch::EmitInverted(), TestAndBranch::EmitInverted(), and InvertBranchType().

void InvokeAccessorGetterCallback	(	v8::Local< v8::String >	property,
		const v8::PropertyCallbackInfo< v8::Value > &	info,
		v8::AccessorGetterCallback	getter
	)

Definition at line 7628 of file api.cc.

References PropertyCallbackInfo< T >::GetIsolate().

void InvokeFunctionCallback	(	const v8::FunctionCallbackInfo< v8::Value > &	info,
		v8::FunctionCallback	callback
	)

Definition at line 7642 of file api.cc.

References FunctionCallbackInfo< T >::GetIsolate().

bool v8::internal::Is ( Object *  obj )

inline

Referenced by RegisterDump::Dump(), TypeImpl< class >::IsCurrently(), PropertyCell::SetValueInferType(), and TEST().

bool v8::internal::Is< JSArray > ( Object *  obj )

inline

Definition at line 832 of file objects-inl.h.

bool v8::internal::Is< JSFunction > ( Object *  obj )

inline

Definition at line 787 of file objects-inl.h.

bool v8::internal::is_intn ( int64_t  x, unsigned  n  )

inline

Definition at line 1102 of file utils.h.

References ASSERT.

bool v8::internal::is_uintn ( int64_t  x, unsigned  n  )

inline

Definition at line 1108 of file utils.h.

References ASSERT, and kBitsPerByte.

bool v8::internal::IsAddressAligned ( Address  addr, intptr_t  alignment, int  offset = 0  )

inline

Definition at line 217 of file utils.h.

References IsAligned(), and OffsetFrom().

Referenced by CodeRange::AllocateRawMemory(), CodeRange::FreeRawMemory(), JavaScriptFrame::GetOperandSlot(), Instruction::InstructionAtOffset(), Zone::New(), and NewSpace::SetUp().

bool v8::internal::IsAligned ( T  value, U  alignment  )

inline

Definition at line 211 of file utils.h.

Referenced by SmallPointerList< v8::internal::Map * >::Add(), FreeList::Allocate(), MemoryAllocator::AllocateChunk(), JavaScriptFrame::ComputeOperandsCount(), Heap::CreateCode(), StaticVisitorBase::GetVisitorIdForSize(), SemiSpace::GrowTo(), NewSpace::INLINE(), IsAddressAligned(), ByteArray::LengthFor(), MarkCompactCollector::MigrateObject(), Heap::MoveBlock(), SmallPointerList< v8::internal::Map * >::Reserve(), Code::set_back_edge_table_offset(), ExternalAsciiString::set_resource(), Code::set_safepoint_table_offset(), FreeListNode::set_size(), SemiSpace::ShrinkTo(), and VirtualMemory::VirtualMemory().

bool v8::internal::isBinaryDigit ( int  x )

inline

Definition at line 55 of file conversions.h.

Referenced by InternalStringToDouble().

bool IsBinaryDigit ( uc32  c )

inline

Definition at line 80 of file char-predicates-inl.h.

bool IsCarriageReturn ( uc32  c )

inline

Definition at line 45 of file char-predicates-inl.h.

bool IsDecimalDigit ( uc32  c )

inline

Definition at line 62 of file char-predicates-inl.h.

References IsInRange().

Referenced by IsHexDigit(), and IsRegExpWord().

bool v8::internal::IsDeclaredVariableMode ( VariableMode  mode )

inline

Definition at line 503 of file v8globals.h.

References MODULE, and VAR.

Referenced by Declaration::Declaration(), Scope::DeclareLocal(), and Variable::IsGlobalObjectProperty().

bool v8::internal::IsDictionaryElementsKind ( ElementsKind  kind )

inline

Definition at line 108 of file elements-kind.h.

References DICTIONARY_ELEMENTS.

Referenced by JSObject::AllocateStorageForMap(), Map::DictionaryElementsInPrototypeChainOnly(), and Map::has_dictionary_elements().

bool v8::internal::isDigit ( int  x, int  radix  )

inline

Definition at line 48 of file conversions.h.

Referenced by InternalStringToDouble(), InternalStringToInt(), and InternalStringToIntDouble().

bool v8::internal::IsDoubleOrFloatElementsKind ( ElementsKind  kind )

inline

Definition at line 159 of file elements-kind.h.

References IsExternalFloatOrDoubleElementsKind(), IsFastDoubleElementsKind(), and IsFixedFloatElementsKind().

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::observed_input_representation(), and V8_FINAL< kOperandKind, kNumCachedOperands >::RequiredInputRepresentation().

bool v8::internal::IsDynamicVariableMode ( VariableMode  mode )

inline

Definition at line 498 of file v8globals.h.

References DYNAMIC, and DYNAMIC_LOCAL.

Referenced by Variable::is_dynamic(), and Variable::IsGlobalObjectProperty().

bool v8::internal::IsExternalArrayElementsKind ( ElementsKind  kind )

inline

Definition at line 113 of file elements-kind.h.

References FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND, and LAST_EXTERNAL_ARRAY_ELEMENTS_KIND.

Referenced by HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), KeyedLoadStubCompiler::CompileElementHandlers(), Map::CopyAsElementsKind(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::Get(), JSTypedArray::GetBuffer(), Map::has_external_array_elements(), V8_FINAL< kOperandKind, kNumCachedOperands >::is_external(), IsTerminalElementsKind(), and RUNTIME_FUNCTION().

bool v8::internal::IsExternalFloatOrDoubleElementsKind ( ElementsKind  kind )

inline

Definition at line 148 of file elements-kind.h.

References EXTERNAL_FLOAT32_ELEMENTS, and EXTERNAL_FLOAT64_ELEMENTS.

Referenced by IsDoubleOrFloatElementsKind().

bool v8::internal::IsFastDoubleElementsKind ( ElementsKind  kind )

inline

Definition at line 142 of file elements-kind.h.

References FAST_DOUBLE_ELEMENTS, and FAST_HOLEY_DOUBLE_ELEMENTS.

Referenced by Heap::AllocateJSArrayAndStorage(), Heap::AllocateJSArrayStorage(), ArrayConstructInitializeElements(), HGraphBuilder::BuildAllocateElements(), HGraphBuilder::BuildCloneShallowArray(), HGraphBuilder::BuildCopyElements(), HGraphBuilder::BuildInitializeElementsHeader(), HGraphBuilder::BuildNewSpaceArrayCheck(), HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), BUILTIN(), Runtime::CreateArrayLiteralBoilerplate(), JSObject::GetElementsKind(), Map::has_fast_double_elements(), JSObject::HasFastDoubleElements(), IsDoubleOrFloatElementsKind(), RUNTIME_FUNCTION(), JSArray::SetContent(), JSObject::TransitionElementsKind(), and FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::ValidateContents().

bool v8::internal::IsFastElementsKind ( ElementsKind  kind )

inline

Definition at line 131 of file elements-kind.h.

References ASSERT, FAST_HOLEY_DOUBLE_ELEMENTS, and FIRST_FAST_ELEMENTS_KIND.

Referenced by CanTransitionToMoreGeneralFastElementsKind(), KeyedLoadStubCompiler::CompileElementHandlers(), Map::CopyAsElementsKind(), Runtime::CreateArrayLiteralBoilerplate(), V8_FINAL< kOperandKind, kNumCachedOperands >::ForArrayLength(), JSObject::GetElementsTransitionMapSlow(), GetNextMoreGeneralFastElementsKind(), Map::has_fast_elements(), JSObject::HasFastElements(), IsTransitionableFastElementsKind(), IsTransitionElementsKind(), RUNTIME_FUNCTION(), JSObject::SetFastElement(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::SetLengthWithoutNormalize(), and JSObject::TransitionElementsKind().

bool v8::internal::IsFastHoleyElementsKind ( ElementsKind  kind )

inline

Definition at line 186 of file elements-kind.h.

References FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, and FAST_HOLEY_SMI_ELEMENTS.

Referenced by ArrayConstructInitializeElements(), HGraphBuilder::BuildTransitionElementsKind(), BUILTIN(), Runtime::CreateArrayLiteralBoilerplate(), JSObject::EnsureCanContainElements(), JSObject::EnsureCanContainHeapObjectElements(), GetNextMoreGeneralFastElementsKind(), JSObject::HasFastHoleyElements(), IsHoleyElementsKind(), Map::IsValidElementsTransition(), RUNTIME_FUNCTION(), JSObject::SetFastElement(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::SetLengthWithoutNormalize(), JSObject::TransitionElementsKind(), and FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::ValidateContents().

bool v8::internal::IsFastObjectElementsKind ( ElementsKind  kind )

inline

Definition at line 180 of file elements-kind.h.

References FAST_ELEMENTS, and FAST_HOLEY_ELEMENTS.

Referenced by HGraphBuilder::BuildCopyElements(), HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), BUILTIN(), Runtime::CreateArrayLiteralBoilerplate(), JSObject::EnsureCanContainHeapObjectElements(), Map::has_fast_object_elements(), JSObject::HasFastObjectElements(), IsSimpleMapChangeTransition(), JSArray::SetContent(), JSObject::SetFastElement(), JSObjectWalkVisitor< ContextObject >::StructureWalk(), and JSObject::TransitionElementsKind().

bool v8::internal::IsFastPackedElementsKind ( ElementsKind  kind )

inline

Definition at line 199 of file elements-kind.h.

References FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by HGraphBuilder::BuildAllocateArrayFromLength(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::CopyElements(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::DeleteCommon(), and Map::FindTransitionedMap().

bool v8::internal::IsFastSmiElementsKind ( ElementsKind  kind )

inline

Definition at line 174 of file elements-kind.h.

References FAST_HOLEY_SMI_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by HGraphBuilder::BuildCopyElements(), HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), JSObject::EnsureCanContainElements(), FastSmiToObjectElementsKind(), AllocationSite::GetMode(), Map::has_fast_smi_elements(), JSObject::HasFastSmiElements(), IsSimpleMapChangeTransition(), V8_FINAL< kOperandKind, kNumCachedOperands >::observed_input_representation(), V8_FINAL< kOperandKind, kNumCachedOperands >::RequiredInputRepresentation(), RUNTIME_FUNCTION(), JSArray::SetContent(), JSObject::TransitionElementsKind(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::ValidateContents(), and V8_FINAL< kOperandKind, kNumCachedOperands >::value_is_smi().

bool v8::internal::IsFastSmiOrObjectElementsKind ( ElementsKind  kind )

inline

Definition at line 166 of file elements-kind.h.

References FAST_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by Heap::AllocateJSArrayAndStorage(), Heap::AllocateJSArrayStorage(), HGraphBuilder::BuildFillElementsWithHole(), BUILTIN(), Runtime::CreateArrayLiteralBoilerplate(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::DeleteCommon(), JSObject::GetElementsKind(), Map::has_fast_smi_or_object_elements(), JSObject::HasFastSmiOrObjectElements(), RUNTIME_FUNCTION(), JSObjectWalkVisitor< ContextObject >::StructureWalk(), JSObject::TransitionElementsKind(), and FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::ValidateContents().

bool v8::internal::IsFixedFloatElementsKind ( ElementsKind  kind )

inline

Definition at line 154 of file elements-kind.h.

References FLOAT32_ELEMENTS, and FLOAT64_ELEMENTS.

Referenced by IsDoubleOrFloatElementsKind().

bool v8::internal::IsFixedTypedArrayElementsKind ( ElementsKind  kind )

inline

Definition at line 125 of file elements-kind.h.

References FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND, and LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND.

Referenced by HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), KeyedLoadStubCompiler::CompileElementHandlers(), Map::has_fixed_typed_array_elements(), V8_FINAL< kOperandKind, kNumCachedOperands >::is_fixed_typed_array(), and IsTransitionElementsKind().

bool IsHexDigit ( uc32  c )

inline

Definition at line 68 of file char-predicates-inl.h.

References AsciiAlphaToLower(), IsDecimalDigit(), and IsInRange().

bool v8::internal::IsHoleyElementsKind ( ElementsKind  kind )

inline

Definition at line 193 of file elements-kind.h.

References DICTIONARY_ELEMENTS, and IsFastHoleyElementsKind().

Referenced by HGraphBuilder::BuildCheckForCapacityGrow(), HGraphBuilder::BuildCopyElements(), BUILTIN(), AllocationSite::DigestTransitionFeedback(), JSObject::SetFastDoubleElementsCapacityAndLength(), JSObject::SetFastElement(), and JSObject::SetFastElementsCapacityAndLength().

bool v8::internal::IsImmutableVariableMode ( VariableMode  mode )

inline

Definition at line 513 of file v8globals.h.

References CONST, CONST_LEGACY, and MODULE.

Referenced by Variable::is_const_mode(), and RUNTIME_FUNCTION().

bool v8::internal::IsInRange ( int  value, int  lower_limit, int  higher_limit  )

inline

Definition at line 55 of file char-predicates-inl.h.

References ASSERT.

Referenced by IsDecimalDigit(), IsHexDigit(), IsOctalDigit(), and IsRegExpWord().

bool v8::internal::IsLexicalVariableMode ( VariableMode  mode )

inline

Definition at line 508 of file v8globals.h.

References LET, and MODULE.

Referenced by Variable::IsGlobalObjectProperty(), and Scope::MustAllocateInContext().

bool IsLineFeed ( uc32  c )

inline

Definition at line 50 of file char-predicates-inl.h.

bool IsMoreGeneralElementsKindTransition	(	ElementsKind	from_kind,
		ElementsKind	to_kind
	)

Definition at line 175 of file elements-kind.cc.

References FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, and FAST_SMI_ELEMENTS.

Referenced by JSObject::AllocateStorageForMap(), BUILTIN(), Map::CopyAsElementsKind(), AllocationSite::DigestTransitionFeedback(), JSObject::GetElementsTransitionMapSlow(), AllocationSite::GetMode(), IC::IsTransitionOfMonomorphicTarget(), Map::IsValidElementsTransition(), KeyedLoadIC::LoadElementStub(), RUNTIME_FUNCTION(), and IC::TryRemoveInvalidPrototypeDependentStub().

bool IsOctalDigit ( uc32  c )

inline

Definition at line 74 of file char-predicates-inl.h.

References IsInRange().

bool v8::internal::IsOutOfBoundsAccess	(	Handle< JSObject >	receiver,
		int	index
	)

Definition at line 1574 of file ic.cc.

References Smi::cast(), and JSArray::cast().

bool v8::internal::IsPowerOf2 ( T  x )

inline

Definition at line 51 of file utils.h.

References IS_POWER_OF_TWO.

Referenced by MacroAssembler::AlignAndSetCSPForFrame(), AlignedAlloc(), MacroAssembler::Claim(), MacroAssembler::ClaimBySMI(), MacroAssembler::Drop(), MacroAssembler::DropBySMI(), InnerPointerToCodeCache::GetCacheEntry(), HashTable< StringTableShape, HashTableKey * >::GetProbe(), StubCache::Initialize(), InternalStringToInt(), HBinaryOperation::RightIsPowerOf2(), RoundDown(), MapSpace::RoundSizeDownToObjectAlignment(), CellSpace::RoundSizeDownToObjectAlignment(), PropertyCellSpace::RoundSizeDownToObjectAlignment(), NewSpace::SetUp(), and WhichPowerOf2().

bool v8::internal::IsQuietNaN ( T  num )

inline

Definition at line 105 of file utils-arm64.h.

References std::isnan(), and IsSignallingNaN().

Referenced by TEST().

bool v8::internal::IsRegExpNewline ( uc32  c )

inline

bool v8::internal::IsRegExpNewline ( uc16  c )

inline

Definition at line 93 of file char-predicates-inl.h.

Referenced by TEST().

bool v8::internal::IsRegExpWord ( uc32  c )

inline

bool v8::internal::IsRegExpWord ( uc16  c )

inline

Definition at line 86 of file char-predicates-inl.h.

References AsciiAlphaToLower(), IsDecimalDigit(), and IsInRange().

Referenced by TEST().

bool v8::internal::IsSignallingNaN ( double  num )

inline

Definition at line 86 of file utils-arm64.h.

References std::isnan(), and kDQuietNanMask.

Referenced by IsQuietNaN(), and TEST().

bool v8::internal::IsSignallingNaN ( float  num )

inline

Definition at line 95 of file utils-arm64.h.

References std::isnan(), and kSQuietNanMask.

bool v8::internal::IsSimpleMapChangeTransition ( ElementsKind  from_kind, ElementsKind  to_kind  )

inline

Definition at line 242 of file elements-kind.h.

References GetHoleyElementsKind(), IsFastObjectElementsKind(), and IsFastSmiElementsKind().

Referenced by HGraphBuilder::BuildTransitionElementsKind().

bool v8::internal::IsTerminalElementsKind ( ElementsKind  kind )

inline

Definition at line 119 of file elements-kind.h.

References IsExternalArrayElementsKind(), and TERMINAL_FAST_ELEMENTS_KIND.

bool v8::internal::IsTransitionableFastElementsKind ( ElementsKind  from_kind )

inline

Definition at line 254 of file elements-kind.h.

References IsFastElementsKind(), and TERMINAL_FAST_ELEMENTS_KIND.

Referenced by Map::FindTransitionedMap(), and JSObject::GetElementsTransitionMapSlow().

bool v8::internal::IsTransitionElementsKind ( ElementsKind  kind )

inline

Definition at line 137 of file elements-kind.h.

References IsFastElementsKind(), and IsFixedTypedArrayElementsKind().

Referenced by JSObject::GetElementsTransitionMapSlow().

int JSCallerSavedCode

(

int

n

)

Definition at line 1610 of file frames.cc.

References ASSERT, kNumJSCallerSaved, and JSCallerSavedCodeData::reg_code.

double v8::internal::JunkStringValue ( )

inline

Definition at line 49 of file conversions-inl.h.

References kQuietNaNMask.

Referenced by InternalStringToDouble(), InternalStringToInt(), and InternalStringToIntDouble().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property keys ( 0 means  random )

override

Referenced by GetEnumPropertyKeys(), RUNTIME_FUNCTION(), JSArray::SetElementsLength(), and TEST().

void lazily_initialize_fast_exp

(

)

Definition at line 320 of file platform-posix.cc.

References NULL.

Referenced by RUNTIME_FUNCTION().

int LinearSearch ( T *  array, Name *  name, int  len, int  valid_entries  )

inline

Definition at line 2487 of file objects-inl.h.

References ALL_ENTRIES, ASSERT, Name::Equals(), and Name::Hash().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric literals	(	0o77	,
		0b11
	)

Referenced by CodeStubGraphBuilderBase::BuildCheckAndInstallOptimizedCode(), StaticMarkingVisitor< StaticVisitor >::MarkInlinedFunctionsCode(), and Factory::NewFunctionFromSharedFunctionInfo().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal logging	(	no	API,
		code	,
		GC	,
		suspect	,
		or handles	samples
	)

Handle< String > LookupSingleCharacterStringFromCode	(	Isolate *	isolate,
		uint32_t	index
	)

Definition at line 212 of file handles.cc.

References CALL_HEAP_FUNCTION, Isolate::heap(), and Heap::LookupSingleCharacterStringFromCode().

Referenced by Factory::NewProperSubString(), and RUNTIME_FUNCTION().

template intptr_t v8::internal::MarkCompactCollector::SweepConservatively< MarkCompactCollector::SWEEP_IN_PARALLEL >	(	PagedSpace *	,
		FreeList *	,
		Page *
	)

template intptr_t v8::internal::MarkCompactCollector::SweepConservatively< MarkCompactCollector::SWEEP_SEQUENTIALLY >	(	PagedSpace *	,
		FreeList *	,
		Page *
	)

int v8::internal::MaskToBit

(

uint64_t

mask

)

Referenced by MacroAssembler::TestAndBranchIfAllClear(), and MacroAssembler::TestAndBranchIfAnySet().

void v8::internal::MathSetup

(

)

Definition at line 212 of file platform-win32.cc.

T v8::internal::Max	(	T	a,
		T	b
	)

Definition at line 227 of file utils.h.

Referenced by Bignum::AddBignum(), Trace::AdvanceCurrentPositionInTrace(), BUILTIN(), Isolate::CaptureCurrentStackTrace(), Isolate::CaptureSimpleStackTrace(), V8_FINAL< kOperandKind, kNumCachedOperands >::ClampToSmi(), RegExpEngine::Compile(), Heap::ConfigureHeap(), CopyBytes(), CopyWords(), Deoptimizer::EnsureCodeForDeoptimizationEntry(), SloppyArgumentsElementsAccessor::GetCapacityImpl(), BinaryOpIC::BASE_EMBEDDED::GetICState(), ICCompareStub::GetICState(), RegExpImpl::GlobalCache::GlobalCache(), BinaryOpIC::BASE_EMBEDDED::HasSideEffects(), Heap::IdleNotification(), Isolate::Init(), DescriptorArray::Merge(), Heap::OldGenerationAllocationLimit(), DefaultPlatform::SetThreadPoolSize(), NewSpace::Shrink(), IncrementalMarking::Step(), StringSearch< PatternChar, SubjectChar >::StringSearch(), JSObject::TooManyFastProperties(), Interval::Union(), IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental(), and Serializer::VisitPointers().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable memory

(

in

Mbytes

)

Referenced by Bootstrapper::AllocateAutoDeletedArray(), OS::MemoryMappedFile::create(), and NoAllocationStringAllocator::NoAllocationStringAllocator().

void MemoryBarrier ( )

inline

Definition at line 36 of file atomicops_internals_arm64_gcc.h.

Referenced by Acquire_Load(), Acquire_Store(), Barrier_AtomicIncrement(), SamplingCircularQueue< T, Length >::Peek(), Release_CompareAndSwap(), Release_Load(), Release_Store(), and SamplingCircularQueue< T, Length >::StartEnqueue().

void v8::internal::MemsetPointer ( T **  dest, U *  value, int  counter  )

inline

Definition at line 198 of file v8utils.h.

References NULL, T, U, and USE().

Referenced by SharedFunctionInfo::AddToOptimizedCodeMap(), Heap::AllocateConstantPoolArray(), CompilationSubCache::Clear(), JSFunctionResultCache::Clear(), EternalHandles::Create(), RUNTIME_FUNCTION(), and Map::ZapPrototypeTransitions().

T v8::internal::Min	(	T	a,
		T	b
	)

Definition at line 234 of file utils.h.

Referenced by OutputStreamWriter::AddSubstring(), CodeEventLogger::NameBuffer::AppendBytes(), CodeEventLogger::NameBuffer::AppendString(), GenericStringUtf16CharacterStream::BufferSeekForward(), BUILTIN(), Isolate::CaptureSimpleStackTrace(), V8_FINAL< kOperandKind, kNumCachedOperands >::ClampToSmi(), MarkCompactCollector::CollectEvacuationCandidates(), Bignum::Compare(), Heap::ConfigureHeap(), CopyBytes(), CopyWords(), DoubleToPrecisionCString(), Factory::EmergencyNewError(), ChoiceNode::Emit(), StringComparator::Equals(), TextNode::FillInBMInfo(), Heap::FreeQueuedChunks(), BinaryOpIC::BASE_EMBEDDED::GetICState(), StringsStorage::GetName(), StaticVisitorBase::GetVisitorIdForSize(), NewSpace::Grow(), Heap::IdleNotification(), Isolate::Init(), V8_FINAL< kOperandKind, kNumCachedOperands >::Intersect(), TypeImpl< class >::Intersect(), EternalHandles::IterateAllRoots(), JSObject::MigrateToMap(), Heap::OldGenerationAllocationLimit(), Bignum::PlusCompare(), RUNTIME_FUNCTION(), Map::set_unused_property_fields(), JSArray::SetElementsLength(), LiveRange::SetSpillStartIndex(), DefaultPlatform::SetThreadPoolSize(), PagedSpace::SizeOfFirstPage(), IncrementalMarking::Step(), TEST(), Interval::Union(), NewSpace::UpdateInlineAllocationLimit(), and IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long mode

(

MIPS

only

)

Referenced by ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::AddElementsToFixedArray(), ArrayConstructInitializeElements(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), BUILTIN(), MarkCompactCollector::CollectEvacuationCandidates(), RegExpEngine::Compile(), Heap::CopyAndTenureFixedCOWArray(), Heap::CopyFixedArrayWithMap(), FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::Delete(), DictionaryElementsAccessor::Delete(), SloppyArgumentsElementsAccessor::Delete(), BinaryOpICStub::GenerateAheadOfTime(), NormalizedMapCache::Get(), V8_FINAL< kOperandKind, kNumCachedOperands >::initialization(), MacroAssembler::li(), Scope::LocalLookup(), Context::Lookup(), Scope::LookupFunctionVar(), BASE_EMBEDDED< Visitor >::ModeMask(), Factory::NewConsString(), ParserBase< Traits >::ParseLeftHandSideExpression(), RegExpMacroAssembler::set_global_mode(), V8_FINAL< kOperandKind, kNumCachedOperands >::set_store_mode(), Heap::SetNewSpaceHighPromotionModeActive(), MarkCompactCollector::SweepConservatively(), and Heap::UpdateAllocationSiteFeedback().

enforce strict mode enable harmony semantics for typeof enable harmony v8::internal::modules

(

implies block

scoping

)

Referenced by Scanner::SetHarmonyModules().

double modulo	(	double	x,
		double	y
	)

Definition at line 300 of file platform-posix.cc.

Referenced by RUNTIME_FUNCTION().

int v8::internal::MostSignificantBit ( uint32_t  x )

inline

Definition at line 89 of file utils.h.

void v8::internal::MoveWords ( T *  dst, const T *  src, size_t  num_words  )

inline

Definition at line 153 of file v8utils.h.

References ASSERT, kPointerSize, OS::MemMove(), STATIC_ASSERT(), and T.

Vector<char> v8::internal::MutableCStrVector ( char *  data )

inline

Definition at line 586 of file utils.h.

References StrLength().

Vector<char> v8::internal::MutableCStrVector ( char *  data, int  max  )

inline

Definition at line 590 of file utils.h.

References StrLength().

Handle<NameDictionary> v8::internal::NameDictionaryShrink	(	Handle< NameDictionary >	dict,
		Handle< Name >	name
	)

Definition at line 769 of file objects.cc.

References CALL_HEAP_FUNCTION.

T v8::internal::NegAbs

(

T

a

)

Definition at line 248 of file utils.h.

Condition NegateCondition ( Condition  cond )

inline

Definition at line 109 of file constants-arm.h.

References al, ASSERT, and ne.

Referenced by TEST().

Hint NegateHint ( Hint  ignored )

inline

Definition at line 428 of file constants-arm.h.

References no_hint.

T* v8::internal::NewArray

(

size_t

size

)

Definition at line 83 of file allocation.h.

References Malloced::FatalProcessOutOfMemory(), NULL, size, and T.

Handle<StringType> v8::internal::NewRawString ( Factory *  factory, int  length, PretenureFlag  pretenure  )

inline

Definition at line 583 of file json-parser.h.

References Factory::NewRawOneByteString(), and Factory::NewRawTwoByteString().

Handle<SeqTwoByteString> v8::internal::NewRawString ( Factory *  factory, int  length, PretenureFlag  pretenure  )

inline

Definition at line 583 of file json-parser.h.

References Factory::NewRawTwoByteString().

Handle<SeqOneByteString> v8::internal::NewRawString ( Factory *  factory, int  length, PretenureFlag  pretenure  )

inline

Definition at line 590 of file json-parser.h.

References Factory::NewRawOneByteString().

AtomicWord v8::internal::NoBarrier_AtomicExchange ( volatile AtomicWord *  ptr, AtomicWord  new_value  )

inline

Definition at line 56 of file atomicops_internals_atomicword_compat.h.

References NoBarrier_AtomicExchange().

Atomic32 NoBarrier_AtomicExchange ( volatile Atomic32 *  ptr, Atomic32  new_value  )

inline

Definition at line 70 of file atomicops_internals_arm64_gcc.h.

Referenced by NoBarrier_AtomicExchange().

Atomic64 NoBarrier_AtomicExchange ( volatile Atomic64 *  ptr, Atomic64  new_value  )

inline

Definition at line 236 of file atomicops_internals_arm64_gcc.h.

AtomicWord v8::internal::NoBarrier_AtomicIncrement ( volatile AtomicWord *  ptr, AtomicWord  increment  )

inline

Definition at line 62 of file atomicops_internals_atomicword_compat.h.

References NoBarrier_AtomicIncrement().

Atomic32 NoBarrier_AtomicIncrement ( volatile Atomic32 *  ptr, Atomic32  increment  )

inline

Definition at line 90 of file atomicops_internals_arm64_gcc.h.

Referenced by Barrier_AtomicIncrement(), Sampler::DecreaseProfilingDepth(), Sampler::IncreaseProfilingDepth(), and NoBarrier_AtomicIncrement().

Atomic64 NoBarrier_AtomicIncrement ( volatile Atomic64 *  ptr, Atomic64  increment  )

inline

Definition at line 256 of file atomicops_internals_arm64_gcc.h.

AtomicWord v8::internal::NoBarrier_CompareAndSwap ( volatile AtomicWord *  ptr, AtomicWord  old_value, AtomicWord  new_value  )

inline

Definition at line 49 of file atomicops_internals_atomicword_compat.h.

References NoBarrier_CompareAndSwap().

Atomic32 NoBarrier_CompareAndSwap ( volatile Atomic32 *  ptr, Atomic32  old_value, Atomic32  new_value  )

inline

Definition at line 44 of file atomicops_internals_arm64_gcc.h.

Referenced by NoBarrier_CompareAndSwap().

Atomic64 NoBarrier_CompareAndSwap ( volatile Atomic64 *  ptr, Atomic64  old_value, Atomic64  new_value  )

inline

Definition at line 210 of file atomicops_internals_arm64_gcc.h.

AtomicWord v8::internal::NoBarrier_Load ( volatile const AtomicWord *  ptr )

inline

Definition at line 103 of file atomicops_internals_atomicword_compat.h.

References NoBarrier_Load().

Atomic32 NoBarrier_Load ( volatile const Atomic32 *  ptr )

inline

Definition at line 192 of file atomicops_internals_arm64_gcc.h.

Referenced by Sampler::IsActive(), Isolate::IsDebuggerActive(), Sampler::IsProfiling(), NoBarrier_Load(), and FreeListCategory::top().

Atomic64 NoBarrier_Load ( volatile const Atomic64 *  ptr )

inline

Definition at line 355 of file atomicops_internals_arm64_gcc.h.

void v8::internal::NoBarrier_Store ( volatile AtomicWord *  ptr, AtomicWord  value  )

inline

Definition at line 88 of file atomicops_internals_atomicword_compat.h.

References NoBarrier_Store().

void NoBarrier_Store ( volatile Atomic32 *  ptr, Atomic32  value  )

inline

Definition at line 178 of file atomicops_internals_arm64_gcc.h.

Referenced by FreeListCategory::Concatenate(), VisitorDispatchTable< ScavengingCallback >::CopyFrom(), NoBarrier_Store(), OptimizingCompilerThread::OptimizingCompilerThread(), FreeListCategory::set_top(), Sampler::SetHasProcessingThread(), and SweeperThread::SweeperThread().

void NoBarrier_Store ( volatile Atomic64 *  ptr, Atomic64  value  )

inline

Definition at line 341 of file atomicops_internals_arm64_gcc.h.

char v8::internal::NormalizeChar ( char  ch )

inline

Definition at line 288 of file flags.cc.

int v8::internal::NumberOfBitsSet ( uint32_t  x )

inline

Definition at line 1037 of file assembler.h.

int32_t v8::internal::NumberToInt32 ( Object *  number )

inline

Definition at line 55 of file v8conversions.h.

References Smi::cast(), DoubleToInt32(), Object::Number(), and Smi::value().

size_t v8::internal::NumberToSize ( Isolate *  isolate, Object *  number  )

inline

Definition at line 103 of file v8conversions.h.

References CHECK, and TryNumberToSize().

Referenced by Runtime::FreeArrayBuffer(), and RUNTIME_FUNCTION().

uint32_t v8::internal::NumberToUint32 ( Object *  number )

inline

Definition at line 61 of file v8conversions.h.

References Smi::cast(), DoubleToUint32(), Object::Number(), and Smi::value().

Referenced by HeapSortPairs(), JSObject::PrepareSlowElementsForSort(), RUNTIME_FUNCTION(), JSArray::SetElementsLength(), and FixedArray::SortPairs().

c_left v8::internal::NumberValueAsInteger32

(

)

-> NumberValueAsInteger32() & 0x1f)) HInstruction* HShr::New( Zone* zone, HValue* context, HValue* left, HValue* right)

Definition at line 4290 of file hydrogen-instructions.cc.

References H_CONSTANT_DOUBLE, and H_CONSTANT_INT.

int NumRegs

(

RegList

reglist

)

Definition at line 1589 of file frames.cc.

References CountSetBits().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions of

(

de

)

intptr_t v8::internal::OffsetFrom ( T  x )

inline

Definition at line 120 of file utils.h.

References T.

Referenced by MemoryChunk::FromAddress(), MemoryChunk::FromAnyPointerAddress(), BASE_EMBEDDED< Visitor >::id(), Page::INLINE(), NewSpace::INLINE(), IsAddressAligned(), Page::IsAlignedToPageSize(), SkipList::RegionNumber(), RoundDown(), and Foreign::set_foreign_address().

Vector<const uint8_t> v8::internal::OneByteVector ( const char *  data, int  length  )

inline

Definition at line 578 of file utils.h.

Referenced by OneByteVector(), and TEST().

Vector<const uint8_t> v8::internal::OneByteVector ( const char *  data )

inline

Definition at line 582 of file utils.h.

References OneByteVector(), and StrLength().

Time v8::internal::operator+ ( const TimeDelta &  delta, const Time &  time  )

inline

Definition at line 306 of file time.h.

TimeTicks v8::internal::operator+ ( const TimeDelta &  delta, const TimeTicks &  ticks  )

inline

Definition at line 410 of file time.h.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction pairs

(

ARM

only

)

Referenced by RUNTIME_FUNCTION().

void v8::internal::PatchInlinedSmiCode	(	Address	address,
		InlinedSmiCheck	check
	)

Referenced by BinaryOpIC::Transition(), and CompareIC::UpdateCaches().

int v8::internal::PointerValueCompare	(	const T *	a,
		const T *	b
	)

Definition at line 172 of file utils.h.

Referenced by ElementCmp< T >::operator()().

double power_double_double	(	double	x,
		double	y
	)

Definition at line 1471 of file assembler.cc.

References std::isfinite(), std::isinf(), std::isnan(), OS::nan_value(), and V8_INFINITY.

Referenced by power_helper(), and RUNTIME_FUNCTION().

double power_double_int	(	double	x,
		int	y
	)

Definition at line 1456 of file assembler.cc.

Referenced by power_helper(), and RUNTIME_FUNCTION().

double power_helper	(	double	x,
		double	y
	)

Definition at line 1436 of file assembler.cc.

References fast_sqrt(), std::isinf(), power_double_double(), power_double_int(), and V8_INFINITY.

Referenced by RUNTIME_FUNCTION().

Vector< const PrecomputedFixed > PrecomputedFixedRepresentations

(

)

Definition at line 100043 of file gay-fixed.cc.

Referenced by TEST().

Vector< const PrecomputedPrecision > PrecomputedPrecisionRepresentations

(

)

Definition at line 100043 of file gay-precision.cc.

Referenced by TEST().

Vector< const PrecomputedShortest > PrecomputedShortestRepresentations

(

)

Definition at line 100043 of file gay-shortest.cc.

Referenced by TEST().

void PrintElementsKind	(	FILE *	out,
		ElementsKind	kind
	)

Definition at line 83 of file elements-kind.cc.

References ElementsKindToString(), and PrintF().

Referenced by JSObject::PrintElementsTransition().

void PRINTF_CHECKING PrintF	(	const char *	format,
			...
	)

Definition at line 40 of file v8utils.cc.

References OS::VPrint().

Referenced by IncrementalMarking::Abort(), Heap::AdjustAmountOfExternalAllocatedMemory(), RegExpMacroAssemblerTracer::AdvanceCurrentPosition(), RegExpMacroAssemblerTracer::AdvanceRegister(), PagedSpace::AdvanceSweeper(), Scope::Analyze(), RuntimeProfiler::AttemptOnStackReplacement(), RegExpMacroAssemblerTracer::Backtrack(), RegExpMacroAssemblerTracer::Bind(), CodeStubGraphBuilderBase::BuildGraph(), CatcherCallback(), CheckArrayAbuse(), RegExpMacroAssemblerTracer::CheckAtStart(), RegExpMacroAssemblerTracer::CheckBitInTable(), RegExpMacroAssemblerTracer::CheckCharacter(), RegExpMacroAssemblerTracer::CheckCharacterAfterAnd(), RegExpMacroAssemblerTracer::CheckCharacterGT(), RegExpMacroAssemblerTracer::CheckCharacterInRange(), RegExpMacroAssemblerTracer::CheckCharacterLT(), RegExpMacroAssemblerTracer::CheckCharacterNotInRange(), RegExpMacroAssemblerTracer::CheckGreedyLoop(), RegExpMacroAssemblerTracer::CheckNotAtStart(), RegExpMacroAssemblerTracer::CheckNotBackReference(), RegExpMacroAssemblerTracer::CheckNotBackReferenceIgnoreCase(), RegExpMacroAssemblerTracer::CheckNotCharacter(), RegExpMacroAssemblerTracer::CheckNotCharacterAfterAnd(), RegExpMacroAssemblerTracer::CheckNotCharacterAfterMinusAnd(), RegExpMacroAssemblerTracer::CheckSpecialCharacterClass(), RegExpMacroAssemblerTracer::ClearRegisters(), MarkCompactCollector::CollectEvacuationCandidates(), CppByteSink::CppByteSink(), OptimizedCompileJob::CreateGraph(), Heap::decrement_scan_on_scavenge_pages(), MessageHandler::DefaultMessageReport(), Deoptimizer::DeoptimizeAll(), Deoptimizer::DeoptimizeGlobalObject(), Deoptimizer::DeoptimizeMarkedCode(), AllocationSite::DigestPretenuringFeedback(), AllocationSite::DigestTransitionFeedback(), SharedFunctionInfo::DisableOptimization(), Isolate::DoThrow(), MarkCompactCollector::EnableCodeFlushing(), AllocationSiteCreationContext::EnterNewScope(), CodeFlusher::EvictCandidate(), SharedFunctionInfo::EvictFromOptimizedCodeMap(), CodeFlusher::EvictOptimizedCodeMap(), AllocationSiteCreationContext::ExitScope(), ParserTraits::ExpressionFromIdentifier(), RegExpMacroAssemblerTracer::Fail(), FailedAccessCheckThrows(), Failure::FailurePrint(), FileByteSink::FileByteSink(), HeapObjectsMap::FindOrAddEntry(), HeapObjectsMap::FindUntrackedObjects(), HCheckTable::Finish(), OptimizingCompilerThread::Flush(), Bitmap::CellPrinter::Flush(), RegExpMacroAssemblerTracer::GetCode(), Compiler::GetConcurrentlyOptimizedCode(), Compiler::GetOptimizedCode(), Deoptimizer::GetOutputInfo(), RegExpMacroAssemblerTracer::GoTo(), HeapNumber::HeapNumberPrint(), IncrementalMarking::Hurry(), RegExpMacroAssemblerTracer::IfRegisterEqPos(), RegExpMacroAssemblerTracer::IfRegisterGE(), RegExpMacroAssemblerTracer::IfRegisterLT(), Heap::increment_scan_on_scavenge_pages(), Isolate::Init(), Snapshot::Initialize(), MarkCompactCollector::INLINE(), OptimizingCompilerThread::InstallOptimizedFunctions(), RegExpImpl::IrregexpExec(), HeapObject::IterateBody(), LoadIC::Load(), RegExpMacroAssemblerTracer::LoadCurrentCharacter(), Context::Lookup(), CodeGenerator::MakeCodePrologue(), JSFunction::MarkForConcurrentOptimization(), IncrementalMarking::MarkingComplete(), JSFunction::MarkInOptimizationQueue(), Deoptimizer::MaterializeHeapObjects(), HeapObjectsMap::MoveObject(), JSObject::NormalizeElements(), JSObject::NormalizeProperties(), RuntimeProfiler::OptimizeNow(), StringStream::OutputToFile(), RegExpMacroAssemblerTracer::PopCurrentPosition(), RegExpMacroAssemblerTracer::PopRegister(), PagedSpace::PrepareForMarkCompact(), AddressToTraceMap::Print(), Bitmap::CellPrinter::Print(), Bitmap::Print(), BASE_EMBEDDED< Visitor >::print(), CodeGenerator::PrintCode(), Isolate::PrintCurrentStackTrace(), Code::PrintDeoptLocation(), PrintElementsKind(), JSObject::PrintElementsTransition(), Map::PrintGeneralization(), JSObject::PrintInstanceMigration(), JSFunction::PrintName(), String::PrintOn(), HSourcePosition::PrintTo(), JavaScriptFrame::PrintTop(), Bitmap::PrintWord(), RegExpMacroAssemblerTracer::PushBacktrack(), RegExpMacroAssemblerTracer::PushCurrentPosition(), RegExpMacroAssemblerTracer::PushRegister(), RegExpMacroAssemblerTracer::ReadCurrentPositionFromRegister(), RegExpMacroAssemblerTracer::ReadStackPointerFromRegister(), RegExpMacroAssemblerTracer::RegExpMacroAssemblerTracer(), NewSpace::ReportStatistics(), HValue::RepresentationFromUses(), MemoryChunk::ResetLiveBytes(), Scope::ResolveVariable(), IncrementalMarking::RestartIfNotMarking(), HRepresentationChangesPhase::Run(), RUNTIME_FUNCTION(), SharedFunctionInfo::SearchOptimizedCodeMap(), RegExpMacroAssemblerTracer::SetCurrentPositionFromEnd(), RegExpMacroAssemblerTracer::SetRegister(), Builtins::SetUp(), AllocationSiteUsageContext::ShouldCreateMemento(), Smi::SmiPrint(), IncrementalMarking::Start(), OptimizingCompilerThread::Stop(), RegExpMacroAssemblerTracer::Succeed(), Heap::TearDown(), TEST(), BinaryOpIC::Transition(), Interface::Unify(), CompareIC::UpdateCaches(), HeapObjectsMap::UpdateHeapObjectsMap(), HValue::UpdateRepresentation(), RegExpMacroAssemblerTracer::WriteCurrentPositionToRegister(), and RegExpMacroAssemblerTracer::WriteStackPointerToRegister().

void FPRINTF_CHECKING PrintF	(	FILE *	out,
		const char *	format,
			...
	)

Definition at line 48 of file v8utils.cc.

References OS::VFPrint().

void PRINTF_CHECKING PrintPID	(	const char *	format,
			...
	)

Definition at line 56 of file v8utils.cc.

References OS::GetCurrentProcessId(), OS::Print(), and OS::VPrint().

Referenced by Heap::AdjustAmountOfExternalAllocatedMemory(), IncrementalMarking::BlackToGreyAndUnshift(), Heap::ConfigureHeap(), IncrementalMarking::NotifyOfHighPromotionRate(), Heap::PrintShortHeapStatistics(), and IncrementalMarking::Step().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux profiler

(

experimental annotate

support

)

Referenced by Heap::AllocateRaw(), and Ticker::SetProfiler().

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset v8::internal::PSEUDO_SMI_ACCESSORS_LO	(	SharedFunctionInfo	,
		expected_nof_properties	,
		kExpectedNofPropertiesOffset
	)

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset kStartPositionAndTypeOffset v8::internal::PSEUDO_SMI_ACCESSORS_LO	(	SharedFunctionInfo	,
		function_token_position	,
		kFunctionTokenPositionOffset
	)

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset kStartPositionAndTypeOffset kCompilerHintsOffset v8::internal::PSEUDO_SMI_ACCESSORS_LO	(	SharedFunctionInfo	,
		opt_count_and_bailout_reason	,
		kOptCountAndBailoutReasonOffset
	)

Definition at line 5210 of file objects-inl.h.

References SharedFunctionInfo::kConstructionCountOffset, and READ_BYTE_FIELD.

typedef v8::internal::PVOID

(

__stdcall *

DLL_FUNC_TYPESymFunctionTableAccess64

)

byte * ReadBytes	(	const char *	filename,
		int *	size,
		bool	verbose
	)

Definition at line 163 of file v8utils.cc.

References ReadCharsFromFile().

Referenced by DEPENDENT_TEST(), and Snapshot::Initialize().

char* v8::internal::ReadCharsFromFile	(	FILE *	file,
		int *	size,
		int	extra_space,
		bool	verbose,
		const char *	filename
	)

Definition at line 122 of file v8utils.cc.

References DeleteArray(), NULL, and OS::PrintError().

Referenced by ReadBytes(), ReadCharsFromFile(), and ReadFile().

char* v8::internal::ReadCharsFromFile	(	const char *	filename,
		int *	size,
		int	extra_space,
		bool	verbose
	)

Definition at line 152 of file v8utils.cc.

References OS::FOpen(), NULL, and ReadCharsFromFile().

Vector< const char > ReadFile	(	const char *	filename,
		bool *	exists,
		bool	verbose
	)

Definition at line 182 of file v8utils.cc.

References ReadCharsFromFile(), and size.

Referenced by SourceGroup::Execute(), Shell::Load(), Shell::Read(), and TEST().

Vector< const char > ReadFile	(	FILE *	file,
		bool *	exists,
		bool	verbose
	)

Definition at line 191 of file v8utils.cc.

References ReadCharsFromFile(), and size.

char * ReadLine

(

const char *

prompt

)

Definition at line 70 of file v8utils.cc.

References ASSERT, DeleteArray(), kCharSize, OS::MemCopy(), NULL, and StrLength().

bool v8::internal::ReceiverObjectNeedsWriteBarrier ( HValue *  object, HValue *  value, HValue *  new_space_dominator  )

inline

Definition at line 5611 of file hydrogen-instructions.h.

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::NeedsWriteBarrier(), and V8_FINAL< kOperandKind, kNumCachedOperands >::NeedsWriteBarrierForMap().

Handle< FixedArray > ReduceFixedArrayTo	(	Handle< FixedArray >	array,
		int	length
	)

Definition at line 615 of file handles.cc.

References ASSERT.

Referenced by GetEnumPropertyKeys().

v8::internal::REGISTER	(	no_reg	,
		-	1
	)

v8::internal::REGISTER	(	zero_reg	,
		0
	)

v8::internal::REGISTER	(	at	,
		1
	)

v8::internal::REGISTER	(	v0	,
		2
	)

v8::internal::REGISTER	(	v1	,
		3
	)

v8::internal::REGISTER	(	a0	,
		4
	)

v8::internal::REGISTER	(	a1	,
		5
	)

v8::internal::REGISTER	(	a2	,
		6
	)

v8::internal::REGISTER	(	a3	,
		7
	)

v8::internal::REGISTER	(	t0	,
		8
	)

v8::internal::REGISTER	(	t1	,
		9
	)

v8::internal::REGISTER	(	t2	,
		10
	)

v8::internal::REGISTER	(	t3	,
		11
	)

v8::internal::REGISTER	(	t4	,
		12
	)

v8::internal::REGISTER	(	t5	,
		13
	)

v8::internal::REGISTER	(	t6	,
		14
	)

v8::internal::REGISTER	(	t7	,
		15
	)

v8::internal::REGISTER	(	s0	,
		16
	)

v8::internal::REGISTER	(	s1	,
		17
	)

v8::internal::REGISTER	(	s2	,
		18
	)

v8::internal::REGISTER	(	s3	,
		19
	)

v8::internal::REGISTER	(	s4	,
		20
	)

v8::internal::REGISTER	(	s5	,
		21
	)

v8::internal::REGISTER	(	s6	,
		22
	)

v8::internal::REGISTER	(	s7	,
		23
	)

v8::internal::REGISTER	(	t8	,
		24
	)

v8::internal::REGISTER	(	t9	,
		25
	)

v8::internal::REGISTER	(	k0	,
		26
	)

v8::internal::REGISTER	(	k1	,
		27
	)

v8::internal::REGISTER	(	gp	,
		28
	)

v8::internal::REGISTER	(	sp	,
		29
	)

v8::internal::REGISTER	(	fp	,
		30
	)

v8::internal::REGISTER	(	ra	,
		31
	)

Handle< JSGlobalProxy > ReinitializeJSGlobalProxy	(	Handle< JSFunction >	constructor,
		Handle< JSGlobalProxy >	global
	)

Definition at line 141 of file handles.cc.

References CALL_HEAP_FUNCTION.

Atomic32 v8::internal::Release_AtomicExchange ( volatile Atomic32 *  ptr, Atomic32  new_value  )

inline

Definition at line 243 of file atomicops_internals_tsan.h.

References __tsan_atomic32_exchange(), and __tsan_memory_order_release.

Atomic64 v8::internal::Release_AtomicExchange ( volatile Atomic64 *  ptr, Atomic64  new_value  )

inline

Definition at line 324 of file atomicops_internals_tsan.h.

References __tsan_atomic64_exchange(), and __tsan_memory_order_release.

AtomicWord v8::internal::Release_CompareAndSwap ( volatile AtomicWord *  ptr, AtomicWord  old_value, AtomicWord  new_value  )

inline

Definition at line 81 of file atomicops_internals_atomicword_compat.h.

References Release_CompareAndSwap().

Atomic32 Release_CompareAndSwap ( volatile Atomic32 *  ptr, Atomic32  old_value, Atomic32  new_value  )

inline

Definition at line 149 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Referenced by Release_CompareAndSwap().

Atomic64 Release_CompareAndSwap ( volatile Atomic64 *  ptr, Atomic64  old_value, Atomic64  new_value  )

inline

Definition at line 313 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

AtomicWord v8::internal::Release_Load ( volatile const AtomicWord *  ptr )

inline

Definition at line 113 of file atomicops_internals_atomicword_compat.h.

References Release_Load().

Atomic32 Release_Load ( volatile const Atomic32 *  ptr )

inline

Definition at line 202 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Referenced by Release_Load().

Atomic64 Release_Load ( volatile const Atomic64 *  ptr )

inline

Definition at line 365 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

void v8::internal::Release_Store ( volatile AtomicWord *  ptr, AtomicWord  value  )

inline

Definition at line 98 of file atomicops_internals_atomicword_compat.h.

References Release_Store().

void Release_Store ( volatile Atomic32 *  ptr, Atomic32  value  )

inline

Definition at line 187 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Referenced by CallOnceImpl(), SamplingCircularQueue< T, Length >::FinishEnqueue(), OptimizingCompilerThread::Flush(), Release_Store(), SamplingCircularQueue< T, Length >::Remove(), OptimizingCompilerThread::Run(), MemoryChunk::set_next_chunk(), MemoryChunk::set_parallel_sweeping(), MemoryChunk::set_prev_chunk(), SweeperThread::Stop(), and OptimizingCompilerThread::Stop().

void Release_Store ( volatile Atomic64 *  ptr, Atomic64  value  )

inline

Definition at line 350 of file atomicops_internals_arm64_gcc.h.

References MemoryBarrier().

Condition ReverseCondition ( Condition  cond )

inline

Definition at line 116 of file constants-arm.h.

References ge, gt, hi, hs, le, lo, ls, and lt.

Condition v8::internal::ReverseConditionForCmp ( Condition  cond )

inline

Definition at line 289 of file constants-arm64.h.

References eq, ge, gt, hi, hs, le, lo, ls, lt, nv, and UNREACHABLE.

T v8::internal::RoundDown ( T  x, intptr_t  m  )

inline

Definition at line 136 of file utils.h.

References ASSERT, IsPowerOf2(), and OffsetFrom().

Referenced by PagedSpace::PagedSpace(), Space::RoundSizeDownToObjectAlignment(), MapSpace::RoundSizeDownToObjectAlignment(), CellSpace::RoundSizeDownToObjectAlignment(), PropertyCellSpace::RoundSizeDownToObjectAlignment(), and SemiSpace::SetUp().

uint32_t v8::internal::RoundDownToPowerOf2 ( uint32_t  x )

inline

Definition at line 203 of file utils.h.

References RoundUpToPowerOf2().

Referenced by MarkingDeque::Initialize().

T v8::internal::RoundUp ( T  x, intptr_t  m  )

inline

Definition at line 144 of file utils.h.

References RoundUp(), and T.

Referenced by AlignUp(), zone_allocator< T >::allocate(), OS::Allocate(), MemoryAllocator::AllocateChunk(), CodeRange::AllocateRawMemory(), Code::body_size(), MemoryAllocator::CodePageGuardStartOffset(), MemoryChunk::CommitArea(), Heap::ConfigureHeap(), Heap::CopyCode(), Heap::CreateCode(), Zone::DeleteAll(), Assembler::EmitStringData(), Zone::New(), MemoryAllocator::ReserveAlignedMemory(), RoundUp(), StoreBuffer::SetUp(), CodeRange::SetUp(), MemoryAllocator::SetUp(), NewSpace::Shrink(), ByteArray::Size(), ConstantPoolArray::SizeFor(), Code::SizeFor(), and VirtualMemory::VirtualMemory().

uint32_t v8::internal::RoundUpToPowerOf2 ( uint32_t  x )

inline

Definition at line 191 of file utils.h.

References ASSERT.

Referenced by HashTable< Shape, Key >::ComputeCapacity(), Heap::ConfigureHeap(), and RoundDownToPowerOf2().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_CreateObjectLiteral
	)

Definition at line 471 of file runtime.cc.

References ASSERT, Handle< T >::cast(), JSObject::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, JSObject::DeepCopy(), JSObject::DeepWalk(), AllocationSiteCreationContext::EnterNewScope(), AllocationSiteUsageContext::EnterNewScope(), AllocationSiteCreationContext::ExitScope(), AllocationSiteUsageContext::ExitScope(), flags, Isolate::heap(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreCallbackProperty
	)

Definition at line 481 of file stub-cache.cc.

References ASSERT, AccessorInfo::IsCompatibleReceiver(), LOG, name, NULL, RETURN_IF_SCHEDULED_EXCEPTION, and Utils::ToLocal().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadPropertyWithInterceptorOnly
	)

Attempts to load a property with an interceptor (which must be present), but doesn't search the prototype chain.

Returns |Heap::no_interceptor_result_sentinel()| if interceptor doesn't provide any value for the given name.

Definition at line 514 of file stub-cache.cc.

References ASSERT, Handle< T >::IsEmpty(), name, NULL, Utils::OpenHandle(), RETURN_IF_SCHEDULED_EXCEPTION, and Utils::ToLocal().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_CreateArrayLiteral
	)

Definition at line 573 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and CONVERT_SMI_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_CreateArrayLiteralStubBailout
	)

Definition at line 586 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and CONVERT_SMI_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CreateSymbol
	)

Definition at line 598 of file runtime.cc.

References ASSERT, name, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CreatePrivateSymbol
	)

Definition at line 611 of file runtime.cc.

References ASSERT, name, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CreateGlobalPrivateSymbol
	)

Definition at line 624 of file runtime.cc.

References ASSERT, Handle< T >::cast(), CONVERT_ARG_HANDLE_CHECKED, Object::GetProperty(), NONE, JSReceiver::SetProperty(), and STRICT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadPropertyWithInterceptorForLoad
	)

Loads a property with an interceptor performing post interceptor lookup if interceptor failed.

Definition at line 626 of file stub-cache.cc.

References ABSENT, NONE, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadPropertyWithInterceptorForCall
	)

Definition at line 638 of file stub-cache.cc.

References RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NewSymbolWrapper
	)

Definition at line 643 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SymbolDescription
	)

Definition at line 650 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreInterceptorProperty
	)

Definition at line 650 of file stub-cache.cc.

References ASSERT, NONE, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SymbolRegistry
	)

Definition at line 658 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SymbolIsPrivate
	)

Definition at line 665 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedLoadPropertyWithInterceptor
	)

Definition at line 666 of file stub-cache.cc.

References ASSERT, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CreateJSProxy
	)

Definition at line 673 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CreateJSFunctionProxy
	)

Definition at line 684 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsJSProxy
	)

Definition at line 699 of file runtime.cc.

References ASSERT, and obj.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsJSFunctionProxy
	)

Definition at line 707 of file runtime.cc.

References ASSERT, and obj.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetHandler
	)

Definition at line 715 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetCallTrap
	)

Definition at line 723 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetConstructTrap
	)

Definition at line 731 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Fix
	)

Definition at line 739 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and JSProxy::Fix().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ArrayBufferInitialize
	)

Definition at line 838 of file runtime.cc.

References ASSERT, Smi::cast(), HeapNumber::cast(), CONVERT_ARG_HANDLE_CHECKED, NULL, Runtime::SetupArrayBufferAllocatingData(), Smi::value(), and HeapNumber::value().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ArrayBufferGetByteLength
	)

Definition at line 872 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ArrayBufferSliceImpl
	)

Definition at line 880 of file runtime.cc.

References ASSERT, CHECK, CONVERT_ARG_HANDLE_CHECKED, CONVERT_DOUBLE_ARG_CHECKED, CopyBytes(), and NumberToSize().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ArrayBufferIsView
	)

Definition at line 901 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ArrayBufferNeuter
	)

Definition at line 911 of file runtime.cc.

References V8::ArrayBufferAllocator(), ASSERT, CHECK, CONVERT_ARG_HANDLE_CHECKED, ArrayBuffer::Allocator::Free(), Smi::FromInt(), Runtime::NeuterArrayBuffer(), NULL, and NumberToSize().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TypedArrayInitialize
	)

Definition at line 952 of file runtime.cc.

References Runtime::ArrayIdToTypeAndSize(), ASSERT, JSArrayBuffer::cast(), CHECK, CHECK_EQ, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, EXTERNAL_INT8_ELEMENTS, Smi::FromInt(), JSObject::GetElementsTransitionMap(), INT8_ELEMENTS, IsExternalArrayElementsKind(), v8::kExternalInt8Array, ArrayBufferView::kInternalFieldCount, Smi::kMaxValue, NULL, and NumberToSize().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TypedArrayInitializeFromArrayLike
	)

Definition at line 1032 of file runtime.cc.

References Runtime::ArrayIdToTypeAndSize(), ASSERT, JSTypedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, EXTERNAL_INT8_ELEMENTS, Smi::FromInt(), JSObject::GetElementsTransitionMap(), INT8_ELEMENTS, v8::kExternalInt8Array, ArrayBufferView::kInternalFieldCount, kMaxInt, Smi::kMaxValue, NULL, NumberToSize(), Runtime::SetupArrayBufferAllocatingData(), and JSTypedArray::type().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TypedArrayGetBuffer
	)

Definition at line 1153 of file runtime.cc.

References ASSERT, JSTypedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TypedArraySetFastCases
	)

Definition at line 1180 of file runtime.cc.

References ASSERT, JSTypedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, Smi::FromInt(), NULL, NumberToSize(), TYPED_ARRAY_SET_NON_TYPED_ARRAY, TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING, TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING, and TYPED_ARRAY_SET_TYPED_ARRAY_SAME_TYPE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TypedArrayMaxSizeInHeap
	)

Definition at line 1238 of file runtime.cc.

References ASSERT_OBJECT_SIZE, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DataViewInitialize
	)

Definition at line 1244 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, Smi::FromInt(), ArrayBufferView::kInternalFieldCount, and NumberToSize().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DataViewGetBuffer
	)

Definition at line 1275 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DataViewGetByteOffset
	)

Definition at line 1283 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DataViewGetByteLength
	)

Definition at line 1291 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetInitialize
	)

Definition at line 1526 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetAdd
	)

Definition at line 1536 of file runtime.cc.

References ObjectHashSet::Add(), ASSERT, ObjectHashSet::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetHas
	)

Definition at line 1548 of file runtime.cc.

References ASSERT, ObjectHashSet::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetDelete
	)

Definition at line 1558 of file runtime.cc.

References ASSERT, ObjectHashSet::cast(), CONVERT_ARG_HANDLE_CHECKED, and ObjectHashSet::Remove().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetGetSize
	)

Definition at line 1570 of file runtime.cc.

References ASSERT, ObjectHashSet::cast(), CONVERT_ARG_HANDLE_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MapInitialize
	)

Definition at line 1579 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MapGet
	)

Definition at line 1589 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MapHas
	)

Definition at line 1600 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MapDelete
	)

Definition at line 1611 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), CONVERT_ARG_HANDLE_CHECKED, and ObjectHashTable::Put().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MapSet
	)

Definition at line 1625 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), CONVERT_ARG_HANDLE_CHECKED, and ObjectHashTable::Put().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MapGetSize
	)

Definition at line 1638 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), CONVERT_ARG_HANDLE_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_WeakCollectionInitialize
	)

Definition at line 1657 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_WeakCollectionGet
	)

Definition at line 1665 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_WeakCollectionHas
	)

Definition at line 1677 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_WeakCollectionDelete
	)

Definition at line 1689 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), CONVERT_ARG_HANDLE_CHECKED, and ObjectHashTable::Put().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_WeakCollectionSet
	)

Definition at line 1704 of file runtime.cc.

References ASSERT, ObjectHashTable::cast(), CONVERT_ARG_HANDLE_CHECKED, and ObjectHashTable::Put().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ClassOf
	)

Definition at line 1718 of file runtime.cc.

References ASSERT, JSObject::cast(), JSReceiver::class_name(), and obj.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetPrototype
	)

Definition at line 1727 of file runtime.cc.

References v8::ACCESS_GET, ASSERT, JSObject::cast(), CONVERT_ARG_HANDLE_CHECKED, Object::GetPrototype(), handle(), Map::is_hidden_prototype(), HeapObject::map(), obj, and RETURN_IF_SCHEDULED_EXCEPTION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		LoadIC_Miss
	)

Definition at line 1757 of file ic.cc.

References ASSERT, and IC::NO_EXTRA_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetPrototype
	)

Definition at line 1761 of file runtime.cc.

References v8::ACCESS_SET, ASSERT, CONVERT_ARG_HANDLE_CHECKED, JSObject::EnqueueChangeRecord(), Map::is_observed(), HeapObject::map(), obj, RETURN_IF_EMPTY_HANDLE, RETURN_IF_SCHEDULED_EXCEPTION, Object::SameValue(), and JSObject::SetPrototype().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedLoadIC_Miss
	)

Definition at line 1769 of file ic.cc.

References ASSERT, and IC::NO_EXTRA_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedLoadIC_MissFromStubFailure
	)

Definition at line 1780 of file ic.cc.

References ASSERT, and IC::EXTRA_CALL_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreIC_Miss
	)

Definition at line 1792 of file ic.cc.

References ASSERT, and IC::NO_EXTRA_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsInPrototypeChain
	)

Definition at line 1796 of file runtime.cc.

References ASSERT, and Object::GetPrototype().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreIC_MissFromStubFailure
	)

Definition at line 1803 of file ic.cc.

References ASSERT, and IC::EXTRA_CALL_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreIC_ArrayLength
	)

Definition at line 1814 of file ic.cc.

References ASSERT, Isolate::heap(), RETURN_IF_EMPTY_HANDLE, and JSArray::SetElementsLength().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		SharedStoreIC_ExtendStorage
	)

Definition at line 1840 of file ic.cc.

References Heap::AllocateHeapNumber(), ASSERT, JSObject::cast(), FixedArray::cast(), Map::cast(), DescriptorArray::GetDetails(), Isolate::heap(), Map::LastAdded(), Object::Number(), FixedArray::set(), and Map::unused_property_fields().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedStoreIC_Miss
	)

Definition at line 1885 of file ic.cc.

References ASSERT, and IC::NO_EXTRA_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedStoreIC_MissFromStubFailure
	)

Definition at line 1896 of file ic.cc.

References ASSERT, and IC::EXTRA_CALL_FRAME.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		StoreIC_Slow
	)

Definition at line 1907 of file ic.cc.

References ASSERT, IC::NO_EXTRA_FRAME, NONE, RETURN_IF_EMPTY_HANDLE, and Runtime::SetObjectProperty().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		KeyedStoreIC_Slow
	)

Definition at line 1924 of file ic.cc.

References ASSERT, IC::NO_EXTRA_FRAME, NONE, RETURN_IF_EMPTY_HANDLE, and Runtime::SetObjectProperty().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		ElementsTransitionAndStoreIC_Miss
	)

Definition at line 1941 of file ic.cc.

References ASSERT, IC::EXTRA_CALL_FRAME, map, NONE, RETURN_IF_EMPTY_HANDLE, Runtime::SetObjectProperty(), and JSObject::TransitionElementsKind().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetOwnProperty
	)

Definition at line 1997 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_PreventExtensions
	)

Definition at line 2008 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, JSObject::PreventExtensions(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsExtensible
	)

Definition at line 2018 of file runtime.cc.

References ASSERT, JSObject::cast(), CONVERT_ARG_CHECKED, JSReceiver::GetPrototype(), Map::is_extensible(), and HeapObject::map().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RegExpCompile
	)

Definition at line 2032 of file runtime.cc.

References ASSERT, RegExpImpl::Compile(), CONVERT_ARG_HANDLE_CHECKED, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CreateApiFunction
	)

Definition at line 2044 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsTemplate
	)

Definition at line 2052 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetTemplateField
	)

Definition at line 2061 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, CONVERT_SMI_ARG_CHECKED, FUNCTION_TEMPLATE_INFO_TYPE, HeapObject::kHeaderSize, kPointerSize, FunctionTemplateInfo::kSize, ObjectTemplateInfo::kSize, OBJECT_TEMPLATE_INFO_TYPE, HeapObject::RawField(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DisableAccessChecks
	)

Definition at line 2080 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, Map::Copy(), Map::is_access_check_needed(), HeapObject::map(), and Map::set_is_access_check_needed().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_EnableAccessChecks
	)

Definition at line 2099 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, Map::Copy(), Map::is_access_check_needed(), HeapObject::map(), and Map::set_is_access_check_needed().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetAccessorProperty
	)

Definition at line 2127 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, JSObject::DefineAccessor(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_DeclareGlobals
	)

Definition at line 2161 of file runtime.cc.

References ABSENT, ASSERT, Handle< T >::cast(), String::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, BitFieldBase< bool, shift, size, uint32_t >::decode(), BitFieldBase< StrictMode, shift, size, uint32_t >::decode(), DONT_DELETE, JSReceiver::GetPropertyAttribute(), name, NONE, pairs(), READ_ONLY, RETURN_IF_EMPTY_HANDLE, JSObject::SetLocalPropertyIgnoreAttributes(), JSReceiver::SetProperty(), and TENURED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_DeclareContextSlot
	)

Definition at line 2256 of file runtime.cc.

References ABSENT, ASSERT, Handle< T >::cast(), Context::cast(), JSObject::cast(), String::cast(), DONT_FOLLOW_CHAINS, Context::extension(), FixedArray::get(), Context::has_extension(), JSReceiver::HasLocalProperty(), Context::IsFunctionContext(), Context::Lookup(), name, NONE, NULL, READ_ONLY, RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, FixedArray::set(), Context::set_extension(), JSObject::SetLocalPropertyIgnoreAttributes(), JSReceiver::SetProperty(), and SLOPPY.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_InitializeVarGlobal
	)

Definition at line 2357 of file runtime.cc.

References ABSENT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_STRICT_MODE_ARG_CHECKED, DONT_DELETE, JSReceiver::GetPropertyAttribute(), RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, JSReceiver::SetProperty(), and JSObject::SetPropertyForResult().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_InitializeConstGlobal
	)

Definition at line 2415 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, FixedArray::get(), READ_ONLY, RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, FixedArray::set(), JSObject::SetLocalPropertyIgnoreAttributes(), JSObject::SetNormalizedProperty(), JSReceiver::SetProperty(), and SLOPPY.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		BinaryOpIC_Miss
	)

Definition at line 2457 of file ic.cc.

References ASSERT_EQ, BinaryOpICStub::kLeft, and BinaryOpICStub::kRight.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		BinaryOpIC_MissWithAllocationSite
	)

Definition at line 2467 of file ic.cc.

References ASSERT_EQ.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_InitializeConstContextSlot
	)

Definition at line 2492 of file runtime.cc.

References ABSENT, ASSERT, Handle< T >::cast(), Context::cast(), String::cast(), Context::extension(), FOLLOW_CHAINS, FixedArray::get(), Context::Lookup(), name, NONE, RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, FixedArray::set(), JSObject::SetNormalizedProperty(), JSReceiver::SetProperty(), SLOPPY, and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_OptimizeObjectForAddingMultipleProperties
	)

Definition at line 2590 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, KEEP_INOBJECT_PROPERTIES, and JSObject::NormalizeProperties().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_RegExpExec
	)

Definition at line 2603 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, RegExpImpl::Exec(), RETURN_IF_EMPTY_HANDLE, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_RegExpConstructResult
	)

Definition at line 2624 of file runtime.cc.

References ASSERT, FixedArray::cast(), JSArray::cast(), CONVERT_SMI_ARG_CHECKED, Smi::FromInt(), JSObject::InObjectPropertyAtPut(), Smi::IsValid(), JSRegExpResult::kIndexIndex, JSRegExpResult::kInputIndex, FixedArray::kMaxLength, JSRegExpResult::kSize, NEW_SPACE, OLD_POINTER_SPACE, and JSArray::set_length().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RegExpInitializeObject
	)

Definition at line 2660 of file runtime.cc.

References ASSERT, JSFunction::cast(), CHECK_NOT_EMPTY_HANDLE, CONVERT_ARG_HANDLE_CHECKED, DONT_DELETE, Smi::FromInt(), JSFunction::initial_map(), JSRegExp::kGlobalFieldIndex, JSRegExp::kIgnoreCaseFieldIndex, JSRegExp::kLastIndexFieldIndex, JSRegExp::kMultilineFieldIndex, JSRegExp::kSourceFieldIndex, map, HeapObject::map(), JSObject::SetLocalPropertyIgnoreAttributes(), SKIP_WRITE_BARRIER, and zero.

v8::internal::RUNTIME_FUNCTION	(	Code *	,
		CompareIC_Miss
	)

Definition at line 2695 of file ic.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FinishArrayPrototypeSetup
	)

Definition at line 2718 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SpecialArrayFunctions
	)

Definition at line 2747 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		CompareNilIC_Miss
	)

Definition at line 2756 of file ic.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsSloppyModeFunction
	)

Definition at line 2764 of file runtime.cc.

References ASSERT, JSFunction::cast(), CONVERT_ARG_CHECKED, Failure::Exception(), SLOPPY, SharedFunctionInfo::strict_mode(), and Execution::TryGetFunctionDelegate().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Unreachable
	)

Definition at line 2764 of file ic.cc.

References CHECK, and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetDefaultReceiver
	)

Definition at line 2782 of file runtime.cc.

References ASSERT, JSFunction::cast(), CONVERT_ARG_CHECKED, Failure::Exception(), Context::global_object(), STRICT, SharedFunctionInfo::strict_mode(), and Execution::TryGetFunctionDelegate().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_MaterializeRegExpLiteral
	)

Definition at line 2810 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, RegExpImpl::CreateRegExpLiteral(), Failure::Exception(), and JSFunction::NativeContextFromLiterals().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		ToBooleanIC_Miss
	)

Definition at line 2821 of file ic.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionGetName
	)

Definition at line 2840 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionSetName
	)

Definition at line 2849 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionNameShouldPrintAsAnonymous
	)

Definition at line 2860 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionMarkNameShouldPrintAsAnonymous
	)

Definition at line 2869 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionIsGenerator
	)

Definition at line 2878 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionRemovePrototype
	)

Definition at line 2886 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionGetScript
	)

Definition at line 2897 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, and GetScriptWrapper().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionGetSourceCode
	)

Definition at line 2909 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionGetScriptSourcePosition
	)

Definition at line 2919 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionGetPositionForOffset
	)

Definition at line 2929 of file runtime.cc.

References ASSERT, code(), CONVERT_ARG_CHECKED, CONVERT_NUMBER_CHECKED, Smi::FromInt(), pc, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionSetInstanceClassName
	)

Definition at line 2943 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionSetLength
	)

Definition at line 2954 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, and CONVERT_SMI_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionSetPrototype
	)

Definition at line 2965 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and Accessors::FunctionSetPrototype().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionSetReadOnlyPrototype
	)

Definition at line 2977 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, Map::CopyReplaceDescriptor(), DescriptorArray::GetDetails(), DescriptorArray::GetValue(), DescriptorArray::kNotFound, HashTable< NameDictionaryShape, Name * >::kNotFound, HeapObject::map(), OMIT_TRANSITION, READ_ONLY, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionIsAPIFunction
	)

Definition at line 3019 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionIsBuiltin
	)

Definition at line 3028 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetCode
	)

Definition at line 3037 of file runtime.cc.

References ASSERT, Handle< T >::cast(), code(), CONVERT_ARG_HANDLE_CHECKED, Compiler::EnsureCompiled(), Failure::Exception(), KEEP_EXCEPTION, JSFunction::kLiteralNativeContextIndex, NULL, RUNTIME_ASSERT, and TENURED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetExpectedNumberOfProperties
	)

Definition at line 3103 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_CreateJSGeneratorObject
	)

Definition at line 3128 of file runtime.cc.

References ASSERT, Context::cast(), JSGeneratorObject::cast(), StandardFrame::context(), JavaScriptFrame::function(), handle(), JavaScriptFrame::IsConstructor(), JavaScriptFrame::receiver(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_SuspendJSGeneratorObject
	)

Definition at line 3154 of file runtime.cc.

References ASSERT, ASSERT_EQ, ASSERT_GE, ASSERT_LT, Context::cast(), JavaScriptFrame::ComputeOperandsCount(), StandardFrame::context(), CONVERT_ARG_CHECKED, JavaScriptFrame::function(), RUNTIME_ASSERT, and JavaScriptFrame::SaveOperandStack().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ResumeJSGeneratorObject
	)

Definition at line 3205 of file runtime.cc.

References ASSERT, ASSERT_EQ, Register::code(), CONVERT_ARG_CHECKED, CONVERT_SMI_ARG_CHECKED, JavaScriptFrame::function(), JSFunction::is_compiled(), JSGeneratorObject::kGeneratorClosed, JSGeneratorObject::kGeneratorExecuting, FixedArrayBase::length(), JSGeneratorObject::NEXT, pc, JavaScriptFrame::RestoreOperandStack(), STATIC_ASSERT(), JSGeneratorObject::THROW, and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ThrowGeneratorStateError
	)

Definition at line 3253 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, JSGeneratorObject::kGeneratorClosed, message, and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ObjectFreeze
	)

Definition at line 3266 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, JSObject::Freeze(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_StringCharCodeAt
	)

Definition at line 3286 of file runtime.cc.

References ASSERT, String::cast(), CONVERT_ARG_CHECKED, CONVERT_NUMBER_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CharFromCode
	)

Definition at line 3310 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringReplaceGlobalRegExpWithString
	)

Definition at line 4240 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and FlattenGetString().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringReplaceOneCharWithString
	)

Definition at line 4316 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, Failure::Exception(), FlattenGetString(), Handle< T >::is_null(), and StringReplaceOneCharWithString().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringIndexOf
	)

Definition at line 4396 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, Smi::FromInt(), RUNTIME_ASSERT, Runtime::StringMatch(), and Object::ToArrayIndex().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringLastIndexOf
	)

Definition at line 4449 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, FlattenString(), Smi::FromInt(), String::FlatContent::IsAscii(), Object::ToArrayIndex(), String::FlatContent::ToOneByteVector(), and String::FlatContent::ToUC16Vector().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringLocaleCompare
	)

Definition at line 4508 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, Smi::FromInt(), and StringCharacterStream::GetNext().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_SubString
	)

Definition at line 4556 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_DOUBLE_ARG_CHECKED, CONVERT_SMI_ARG_CHECKED, FastD2IChecked(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringMatch
	)

Definition at line 4584 of file runtime.cc.

References ASSERT_EQ, CONVERT_ARG_HANDLE_CHECKED, Failure::Exception(), Smi::FromInt(), NULL, and RegExpImpl::SetLastMatchInfo().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RegExpExecMultiple
	)

Definition at line 4792 of file runtime.cc.

References ASSERT, JSRegExp::CaptureCount(), CONVERT_ARG_HANDLE_CHECKED, FlattenString(), JSRegExp::GetFlags(), JSRegExp::Flags::is_global(), and String::IsFlat().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToRadixString
	)

Definition at line 4814 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, CONVERT_SMI_ARG_CHECKED, CStrVector(), DeleteArray(), DoubleToRadixCString(), std::isinf(), std::isnan(), LookupSingleCharacterStringFromCode(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToFixed
	)

Definition at line 4850 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, CStrVector(), DeleteArray(), DoubleToFixedCString(), FastD2IChecked(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToExponential
	)

Definition at line 4866 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, CStrVector(), DeleteArray(), DoubleToExponentialCString(), FastD2IChecked(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToPrecision
	)

Definition at line 4882 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, CStrVector(), DeleteArray(), DoubleToPrecisionCString(), FastD2IChecked(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsValidSmi
	)

Definition at line 4898 of file runtime.cc.

References ASSERT, CONVERT_NUMBER_CHECKED, and Smi::IsValid().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetProperty
	)

Definition at line 5027 of file runtime.cc.

References ASSERT, and Runtime::GetObjectProperty().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_KeyedGetProperty
	)

Definition at line 5039 of file runtime.cc.

References ASSERT, JSObject::cast(), Name::cast(), PropertyCell::cast(), Dictionary< Shape, Key >::DetailsAt(), FAST_ELEMENTS, FAST_HOLEY_ELEMENTS, JSObject::FastPropertyAt(), NameDictionary::FindEntry(), Runtime::GetObjectProperty(), JSObject::HasFastProperties(), Isolate::heap(), IsFastDoubleElementsKind(), IsFastElementsKind(), IsFastHoleyElementsKind(), IsFastSmiOrObjectElementsKind(), Isolate::keyed_lookup_cache(), HashTable< NameDictionaryShape, Name * >::kNotFound, FixedArrayBase::length(), JSReceiver::LocalLookup(), KeyedLookupCache::Lookup(), HeapObject::map(), NORMAL, JSObject::property_dictionary(), JSObject::RawFastPropertyAt(), TransitionElements(), KeyedLookupCache::Update(), Smi::value(), and Dictionary< Shape, Key >::ValueAt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DefineOrRedefineAccessorProperty
	)

Definition at line 5154 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, JSObject::DefineAccessor(), Isolate::heap(), RETURN_IF_SCHEDULED_EXCEPTION, RUNTIME_ASSERT, and JSObject::TransformToFastProperties().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DefineOrRedefineDataProperty
	)

Definition at line 5182 of file runtime.cc.

References ASSERT, JSObject::cast(), CLEAR_INOBJECT_PROPERTIES, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, Runtime::ForceSetObjectProperty(), handle(), Isolate::heap(), JSObject::NormalizeProperties(), RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, JSObject::SetLocalPropertyIgnoreAttributes(), JSObject::SetPropertyWithCallback(), and STRICT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetDataProperty
	)

Definition at line 5254 of file runtime.cc.

References ASSERT, CALLBACKS, CONSTANT, CONVERT_ARG_HANDLE_CHECKED, FIELD, HANDLER, Isolate::heap(), INTERCEPTOR, NONEXISTENT, NORMAL, TRANSITION, and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetHiddenProperty
	)

Definition at line 5485 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, RUNTIME_ASSERT, and JSObject::SetHiddenProperty().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetProperty
	)

Definition at line 5496 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, CONVERT_STRICT_MODE_ARG_CHECKED, RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, Runtime::SetObjectProperty(), and SLOPPY.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TransitionElementsKind
	)

Definition at line 5525 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, RUNTIME_ASSERT, and JSObject::TransitionElementsKind().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetNativeFlag
	)

Definition at line 5538 of file runtime.cc.

References JSFunction::cast(), CONVERT_ARG_CHECKED, Isolate::heap(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetInlineBuiltinFlag
	)

Definition at line 5552 of file runtime.cc.

References JSFunction::cast(), Isolate::heap(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StoreArrayLiteralElement
	)

Definition at line 5566 of file runtime.cc.

References ASSERT, HeapNumber::cast(), FixedArray::cast(), FixedDoubleArray::cast(), AllocationSite::cast(), JSArray::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, IsFastDoubleElementsKind(), IsFastElementsKind(), IsFastHoleyElementsKind(), IsFastSmiElementsKind(), IsMoreGeneralElementsKindTransition(), NULL, RUNTIME_ASSERT, FixedArray::set(), FixedDoubleArray::set(), and JSObject::TransitionElementsKind().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DebugCallbackSupportsStepping
	)

Definition at line 5625 of file runtime.cc.

References JSFunction::cast(), CONVERT_ARG_CHECKED, Isolate::heap(), JSFunction::IsBuiltin(), and Isolate::IsDebuggerActive().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DebugPrepareStepInIfStepping
	)

Definition at line 5645 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, and Isolate::heap().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IgnoreAttributesAndSetProperty
	)

Definition at line 5664 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, NONE, RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, and JSObject::SetLocalPropertyIgnoreAttributes().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DeleteProperty
	)

Definition at line 5686 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_STRICT_MODE_ARG_CHECKED, JSReceiver::DeleteProperty(), JSReceiver::NORMAL_DELETION, RETURN_IF_EMPTY_HANDLE, STRICT, and JSReceiver::STRICT_DELETION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_HasLocalProperty
	)

Definition at line 5721 of file runtime.cc.

References Name::AsArrayIndex(), ASSERT, Handle< T >::cast(), HeapObject::cast(), CONVERT_ARG_HANDLE_CHECKED, Map::has_named_interceptor(), JSObject::HasRealNamedProperty(), map, and RETURN_IF_SCHEDULED_EXCEPTION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_HasProperty
	)

Definition at line 5763 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, Failure::Exception(), JSReceiver::HasProperty(), and RETURN_IF_SCHEDULED_EXCEPTION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_HasElement
	)

Definition at line 5776 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, Failure::Exception(), JSReceiver::HasElement(), and RETURN_IF_SCHEDULED_EXCEPTION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsPropertyEnumerable
	)

Definition at line 5789 of file runtime.cc.

References ABSENT, ASSERT, CONVERT_ARG_HANDLE_CHECKED, JSReceiver::GetLocalPropertyAttribute(), and RETURN_IF_SCHEDULED_EXCEPTION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetPropertyNames
	)

Definition at line 5806 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, Failure::Exception(), and GetKeysFor().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetPropertyNamesFast
	)

Definition at line 5822 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, Failure::Exception(), GetKeysInFixedArrayFor(), and INCLUDE_PROTOS.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetLocalPropertyNames
	)

Definition at line 5862 of file runtime.cc.

References v8::ACCESS_KEYS, ASSERT, ASSERT_EQ, JSObject::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, JSObject::HasHiddenProperties(), obj, RETURN_IF_SCHEDULED_EXCEPTION, and STRING.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetLocalElementNames
	)

Definition at line 5978 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and NONE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetInterceptorInfo
	)

Definition at line 5995 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetNamedInterceptorPropertyNames
	)

Definition at line 6013 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, GetKeysForNamedInterceptor(), Handle< T >::IsEmpty(), and Utils::OpenHandle().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetIndexedInterceptorElementNames
	)

Definition at line 6028 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, GetKeysForIndexedInterceptor(), Handle< T >::IsEmpty(), and Utils::OpenHandle().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_LocalKeys
	)

Definition at line 6041 of file runtime.cc.

References v8::ACCESS_KEYS, ASSERT, ASSERT_EQ, Handle< T >::cast(), CONVERT_ARG_CHECKED, Failure::Exception(), GetKeysInFixedArrayFor(), Value::IsNull(), LOCAL_ONLY, and RETURN_IF_SCHEDULED_EXCEPTION.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetArgumentsProperty
	)

Definition at line 6091 of file runtime.cc.

References ASSERT, Handle< T >::cast(), Symbol::cast(), JavaScriptFrame::ComputeParametersCount(), Failure::Exception(), Smi::FromInt(), JavaScriptFrame::function(), Object::GetElement(), JavaScriptFrame::GetParameter(), NULL, RETURN_IF_EMPTY_HANDLE, STRICT, and Execution::ToString().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ToFastProperties
	)

Definition at line 6153 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and JSObject::TransformToFastProperties().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ToBool
	)

Definition at line 6164 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Typeof
	)

Definition at line 6174 of file runtime.cc.

References ASSERT, HeapObject::cast(), FIRST_NONSTRING_TYPE, Map::instance_type(), Map::is_undetectable(), JS_FUNCTION_PROXY_TYPE, JS_FUNCTION_TYPE, HeapObject::map(), ODDBALL_TYPE, and SYMBOL_TYPE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringToNumber
	)

Definition at line 6238 of file runtime.cc.

References ALLOW_BINARY, ALLOW_HEX, ALLOW_OCTAL, ASSERT, ASSERT_EQ, SeqOneByteString::cast(), CONVERT_ARG_CHECKED, flags, Smi::FromInt(), SeqOneByteString::GetChars(), Name::Hash(), Name::hash_field(), Name::HasHashCode(), String::kMaxArrayIndexSize, String::length(), StringHasher::MakeArrayIndexHash(), Name::set_hash_field(), StringToDouble(), and String::TryFlatten().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NewString
	)

Definition at line 6299 of file runtime.cc.

References CONVERT_BOOLEAN_ARG_CHECKED, and CONVERT_SMI_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TruncateString
	)

Definition at line 6312 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, and SeqString::Truncate().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_URIEscape
	)

Definition at line 6320 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, FlattenGetString(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_URIUnescape
	)

Definition at line 6334 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and FlattenGetString().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_QuoteJSONString
	)

Definition at line 6346 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_BasicJSONStringify
	)

Definition at line 6354 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringParseInt
	)

Definition at line 6362 of file runtime.cc.

References CONVERT_ARG_CHECKED, CONVERT_SMI_ARG_CHECKED, RUNTIME_ASSERT, and StringToInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringParseFloat
	)

Definition at line 6376 of file runtime.cc.

References ALLOW_TRAILING_JUNK, CONVERT_ARG_CHECKED, OS::nan_value(), and StringToDouble().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringToLowerCase
	)

Definition at line 6682 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringToUpperCase
	)

Definition at line 6688 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringTrim
	)

Definition at line 6694 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_BOOLEAN_ARG_CHECKED, FlattenGetString(), and UnicodeCache::IsWhiteSpaceOrLineTerminator().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringSplit
	)

Definition at line 6727 of file runtime.cc.

References ASSERT, FixedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_NUMBER_CHECKED, JSObject::EnsureCanContainHeapObjectElements(), RegExpResultsCache::Enter(), FindStringIndicesDispatch(), FlattenString(), Smi::FromInt(), String::IsFlat(), String::length(), RegExpResultsCache::Lookup(), RUNTIME_ASSERT, and RegExpResultsCache::STRING_SPLIT_SUBSTRINGS.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringToArray
	)

Definition at line 6852 of file runtime.cc.

References ASSERT, FixedArray::cast(), String::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_NUMBER_CHECKED, FlattenGetString(), String::FlatContent::IsAscii(), LookupSingleCharacterStringFromCode(), MemsetPointer(), obj, Vector< T >::start(), and String::FlatContent::ToOneByteVector().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NewStringWrapper
	)

Definition at line 6905 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, and Value::ToObject().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NumberToString
	)

Definition at line 6920 of file runtime.cc.

References ASSERT, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NumberToStringSkipCache
	)

Definition at line 6931 of file runtime.cc.

References ASSERT, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToInteger
	)

Definition at line 6942 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, DoubleToInteger(), Smi::FromInt(), and Smi::kMaxValue.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToIntegerMapMinusZero
	)

Definition at line 6956 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, DoubleToInteger(), Smi::FromInt(), and Smi::kMaxValue.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToJSUint32
	)

Definition at line 6975 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberToJSInt32
	)

Definition at line 6984 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, DoubleToInt32(), Smi::FromInt(), and Smi::kMaxValue.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NumberToSmi
	)

Definition at line 7000 of file runtime.cc.

References ASSERT, HeapNumber::cast(), FastD2I(), FastI2D(), Smi::FromInt(), Smi::IsValid(), obj, and HeapNumber::value().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_AllocateHeapNumber
	)

Definition at line 7019 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberAdd
	)

Definition at line 7026 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberSub
	)

Definition at line 7036 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberMul
	)

Definition at line 7046 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberUnaryMinus
	)

Definition at line 7056 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberAlloc
	)

Definition at line 7065 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberDiv
	)

Definition at line 7073 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberMod
	)

Definition at line 7083 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, and modulo().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberImul
	)

Definition at line 7096 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_StringAdd
	)

Definition at line 7106 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringBuilderConcat
	)

Definition at line 7157 of file runtime.cc.

References ASSERT, Smi::cast(), FixedArray::cast(), String::cast(), SeqOneByteString::cast(), SeqTwoByteString::cast(), CONVERT_ARG_HANDLE_CHECKED, BitFieldBase< T, shift, size, uint32_t >::decode(), JSObject::EnsureCanContainHeapObjectElements(), FixedArray::get(), SeqOneByteString::GetChars(), SeqTwoByteString::GetChars(), String::HasOnlyOneByteChars(), String::kMaxLength, Smi::kMaxValue, FixedArrayBase::length(), String::length(), and Smi::value().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringBuilderJoin
	)

Definition at line 7269 of file runtime.cc.

References ASSERT, FixedArray::cast(), String::cast(), CONVERT_ARG_HANDLE_CHECKED, kMaxInt, String::kMaxLength, String::length(), RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, STATIC_ASSERT(), and String::WriteToFlat().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SparseJoinWithSeparator
	)

Definition at line 7387 of file runtime.cc.

References ASSERT, FixedArray::cast(), String::cast(), SeqOneByteString::cast(), SeqTwoByteString::cast(), CONVERT_ARG_CHECKED, CONVERT_NUMBER_CHECKED, FixedArray::get(), SeqOneByteString::GetChars(), SeqTwoByteString::GetChars(), String::kMaxLength, String::length(), overflow, RUNTIME_ASSERT, and STATIC_ASSERT().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberOr
	)

Definition at line 7478 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberAnd
	)

Definition at line 7488 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberXor
	)

Definition at line 7498 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberShl
	)

Definition at line 7508 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberShr
	)

Definition at line 7518 of file runtime.cc.

References ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberSar
	)

Definition at line 7528 of file runtime.cc.

References ArithmeticShiftRight(), ASSERT, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberEquals
	)

Definition at line 7538 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, EQUAL, FP_ZERO, std::fpclassify(), Smi::FromInt(), std::isnan(), and NOT_EQUAL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_StringEquals
	)

Definition at line 7557 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, EQUAL, Smi::FromInt(), not_equal, NOT_EQUAL, and STATIC_CHECK().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NumberCompare
	)

Definition at line 7575 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, EQUAL, Smi::FromInt(), GREATER, std::isless(), std::isnan(), and LESS.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SmiLexicographicCompare
	)

Definition at line 7590 of file runtime.cc.

References ASSERT, CONVERT_SMI_ARG_CHECKED, EQUAL, Smi::FromInt(), GREATER, IntegerLog2(), and LESS.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_StringCompare
	)

Definition at line 7729 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, EQUAL, Smi::FromInt(), GREATER, LESS, and obj.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DoubleHi
	)

Definition at line 7780 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, and double_to_uint64().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DoubleLo
	)

Definition at line 7790 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, and double_to_uint64().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ConstructDouble
	)

Definition at line 7799 of file runtime.cc.

References ASSERT, CONVERT_NUMBER_CHECKED, hi, lo, and uint64_to_double().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_atan2
	)

Definition at line 7812 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, and std::isinf().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_exp
	)

Definition at line 7835 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, fast_exp(), and lazily_initialize_fast_exp().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_floor
	)

Definition at line 7846 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_pow
	)

Definition at line 7858 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, std::isnan(), power_double_int(), and power_helper().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_pow_cfunction
	)

Definition at line 7881 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, Smi::FromInt(), std::isnan(), and power_double_double().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RoundNumber
	)

Definition at line 7898 of file runtime.cc.

References ASSERT, Smi::FromInt(), HeapNumber::get_exponent(), HeapNumber::get_sign(), kSmiValueSize, sign, and HeapNumber::value().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_sqrt
	)

Definition at line 7941 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, and fast_sqrt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Math_fround
	)

Definition at line 7951 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateMakeDay
	)

Definition at line 7961 of file runtime.cc.

References ASSERT, CONVERT_SMI_ARG_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateSetValue
	)

Definition at line 7972 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_DOUBLE_ARG_CHECKED, CONVERT_SMI_ARG_CHECKED, DoubleToInteger(), std::isnan(), DateCache::kMaxTimeBeforeUTCInMs, DateCache::kMaxTimeInMs, NULL, and DateCache::ToUTC().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewArgumentsFast
	)

Definition at line 8009 of file runtime.cc.

References ASSERT, Smi::cast(), Smi::FromInt(), Min(), Context::MIN_CONTEXT_SLOTS, name, NOT_TENURED, SLOPPY_ARGUMENTS_ELEMENTS, and Smi::value().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewStrictArgumentsFast
	)

Definition at line 8104 of file runtime.cc.

References ASSERT, JSObject::cast(), JSFunction::cast(), HeapObject::GetWriteBarrierMode(), and FixedArray::set().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewClosureFromStubFailure
	)

Definition at line 8137 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and NOT_TENURED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewClosure
	)

Definition at line 8151 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_BOOLEAN_ARG_CHECKED, NOT_TENURED, and TENURED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FunctionBindArguments
	)

Definition at line 8219 of file runtime.cc.

References ASSERT, JSFunction::cast(), CONVERT_ARG_HANDLE_CHECKED, ForceSetProperty(), JSFunction::function_bindings(), JSFunction::kBoundArgumentsStartIndex, JSFunction::kBoundFunctionIndex, JSFunction::kBoundThisIndex, READ_ONLY, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_BoundFunctionGetBindings
	)

Definition at line 8279 of file runtime.cc.

References ASSERT, Handle< T >::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NewObjectFromBound
	)

Definition at line 8295 of file runtime.cc.

References ASSERT, Handle< T >::cast(), JSReceiver::cast(), FixedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, Failure::Exception(), SmartPointerBase< ArrayDeallocator< T >, T >::get(), JSFunction::kBoundArgumentsStartIndex, JSFunction::kBoundFunctionIndex, Execution::New(), RUNTIME_ASSERT, and Execution::TryGetConstructorDelegate().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewObject
	)

Definition at line 8417 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewObjectWithAllocationSite
	)

Definition at line 8428 of file runtime.cc.

References ASSERT, and Handle< T >::cast().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_FinalizeInstanceSize
	)

Definition at line 8445 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_CompileUnoptimized
	)

Definition at line 8456 of file runtime.cc.

References ASSERT, code(), Compiler::GetUnoptimizedCode(), PrintF(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_CompileOptimized
	)

Definition at line 8485 of file runtime.cc.

References ASSERT, code(), Compiler::CONCURRENT, CONVERT_BOOLEAN_ARG_CHECKED, Compiler::GetOptimizedCode(), Handle< T >::is_null(), Compiler::NOT_CONCURRENT, and PrintF().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NotifyStubFailure
	)

Definition at line 8548 of file runtime.cc.

References ASSERT, and Deoptimizer::Grab().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NotifyDeoptimized
	)

Definition at line 8558 of file runtime.cc.

References ASSERT, Deoptimizer::bailout_type(), Deoptimizer::compiled_code(), Deoptimizer::DeoptimizeFunction(), Deoptimizer::function(), JavaScriptFrame::function(), Deoptimizer::Grab(), ActivationsFinder::has_code_activations_, Deoptimizer::LAZY, Deoptimizer::MaterializeHeapObjects(), PrintF(), RUNTIME_ASSERT, and ActivationsFinder::VisitFrames().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DeoptimizeFunction
	)

Definition at line 8617 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and Deoptimizer::DeoptimizeFunction().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ClearFunctionTypeFeedback
	)

Definition at line 8629 of file runtime.cc.

References ASSERT, Code::ClearInlineCaches(), Code::ClearTypeFeedbackInfo(), CONVERT_ARG_HANDLE_CHECKED, and Code::kind().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RunningInSimulator
	)

Definition at line 8642 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsConcurrentRecompilationSupported
	)

Definition at line 8652 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_OptimizeFunctionOnNextCall
	)

Definition at line 8659 of file runtime.cc.

References Code::allow_osr_at_loop_nesting_level(), ASSERT, CONVERT_ARG_HANDLE_CHECKED, Code::kind(), Code::kMaxLoopNestingMarker, RUNTIME_ASSERT, Code::set_allow_osr_at_loop_nesting_level(), and STATIC_ASCII_VECTOR.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NeverOptimizeFunction
	)

Definition at line 8694 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetOptimizationStatus
	)

Definition at line 8703 of file runtime.cc.

References CONVERT_ARG_HANDLE_CHECKED, Smi::FromInt(), RUNTIME_ASSERT, OS::Sleep(), and STATIC_ASCII_VECTOR.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_UnblockConcurrentRecompilation
	)

Definition at line 8738 of file runtime.cc.

References RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetOptimizationCount
	)

Definition at line 8746 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and Smi::FromInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CompileForOnStackReplacement
	)

Definition at line 8773 of file runtime.cc.

References BackEdgeTable::AddStackCheck(), ASSERT, ASSERT_EQ, DeoptimizationInputData::cast(), Compiler::CONCURRENT, CONVERT_ARG_HANDLE_CHECKED, OptimizingCompilerThread::FindReadyOSRCandidate(), JavaScriptFrame::function(), Compiler::GetConcurrentlyOptimizedCode(), Compiler::GetOptimizedCode(), Handle< T >::is_null(), BailoutId::IsNone(), OptimizingCompilerThread::IsQueuedForOSR(), Compiler::NOT_CONCURRENT, Handle< T >::null(), NULL, PrintF(), BackEdgeTable::Revert(), and BailoutId::ToInt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetAllocationTimeout
	)

Definition at line 8886 of file runtime.cc.

References ASSERT, CONVERT_BOOLEAN_ARG_CHECKED, and CONVERT_SMI_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CheckIsBootstrapping
	)

Definition at line 8908 of file runtime.cc.

References RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetRootNaN
	)

Definition at line 8915 of file runtime.cc.

References RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Call
	)

Definition at line 8922 of file runtime.cc.

References ASSERT, Execution::Call(), CONVERT_ARG_CHECKED, Failure::Exception(), and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Apply
	)

Definition at line 8958 of file runtime.cc.

References ASSERT, Execution::Call(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, Failure::Exception(), Object::GetElement(), NULL, RETURN_IF_EMPTY_HANDLE, and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetFunctionDelegate
	)

Definition at line 8994 of file runtime.cc.

References ASSERT, Execution::GetFunctionDelegate(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetConstructorDelegate
	)

Definition at line 9002 of file runtime.cc.

References ASSERT, Execution::GetConstructorDelegate(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewGlobalContext
	)

Definition at line 9010 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, and Context::global_object().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_NewFunctionContext
	)

Definition at line 9029 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_PushWithContext
	)

Definition at line 9039 of file runtime.cc.

References ASSERT, Failure::cast(), JSReceiver::cast(), JSFunction::cast(), handle(), HandleVector(), and Failure::IsInternalError().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_PushCatchContext
	)

Definition at line 9083 of file runtime.cc.

References ASSERT, JSFunction::cast(), String::cast(), and name.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_PushBlockContext
	)

Definition at line 9109 of file runtime.cc.

References ASSERT, ScopeInfo::cast(), and JSFunction::cast().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsJSModule
	)

Definition at line 9133 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_PushModuleContext
	)

Definition at line 9141 of file runtime.cc.

References ASSERT, Context::cast(), Context::closure(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, FixedArray::get(), Context::global_context(), Context::global_object(), Factory::NewJSModule(), Factory::NewModuleContext(), Context::previous(), FixedArray::set(), Context::set_closure(), Context::set_global_object(), Context::set_module(), and Context::set_previous().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_DeclareModules
	)

Definition at line 9176 of file runtime.cc.

References ASSERT, ModuleInfo::cast(), Context::cast(), CONST, CONST_LEGACY, CONVERT_ARG_HANDLE_CHECKED, DYNAMIC, DYNAMIC_GLOBAL, DYNAMIC_LOCAL, FROZEN, FixedArray::get(), INTERNAL, IsImmutableVariableMode(), LET, Accessors::MakeModuleExport(), Context::module(), MODULE, name, JSObject::PreventExtensions(), SEALED, JSObject::SetAccessor(), JSReceiver::SetProperty(), STRICT, TEMPORARY, UNREACHABLE, USE(), and VAR.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_DeleteContextSlot
	)

Definition at line 9229 of file runtime.cc.

References ASSERT, Handle< T >::cast(), CONVERT_ARG_HANDLE_CHECKED, JSReceiver::DeleteProperty(), FOLLOW_CHAINS, JSReceiver::Lookup(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	ObjectPair	,
		RuntimeHidden_LoadContextSlot
	)

Definition at line 9415 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	ObjectPair	,
		RuntimeHidden_LoadContextSlotNoReferenceError
	)

Definition at line 9420 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_StoreContextSlot
	)

Definition at line 9425 of file runtime.cc.

References ABSENT, ASSERT, Handle< T >::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_STRICT_MODE_ARG_CHECKED, Failure::Exception(), FOLLOW_CHAINS, FixedArray::get(), JSReceiver::GetLocalPropertyAttribute(), HandleVector(), Object::Lookup(), MUTABLE_CHECK_INITIALIZED, NONE, RETURN_IF_EMPTY_HANDLE, FixedArray::set(), JSReceiver::SetProperty(), and STRICT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_Throw
	)

Definition at line 9510 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ReThrow
	)

Definition at line 9518 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_PromoteScheduledException
	)

Definition at line 9526 of file runtime.cc.

References ASSERT_EQ.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ThrowReferenceError
	)

Definition at line 9533 of file runtime.cc.

References ASSERT, HandleVector(), and name.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ThrowNotDateError
	)

Definition at line 9545 of file runtime.cc.

References ASSERT, and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ThrowMessage
	)

Definition at line 9553 of file runtime.cc.

References ASSERT, CONVERT_SMI_ARG_CHECKED, CStrVector(), GetBailoutReason(), message, and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_StackGuard
	)

Definition at line 9566 of file runtime.cc.

References ASSERT, and Execution::HandleStackGuardInterrupt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_TryInstallOptimizedCode
	)

Definition at line 9579 of file runtime.cc.

References ASSERT, and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_Interrupt
	)

Definition at line 9596 of file runtime.cc.

References ASSERT, and Execution::HandleStackGuardInterrupt().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TraceEnter
	)

Definition at line 9632 of file runtime.cc.

References ASSERT, and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TraceExit
	)

Definition at line 9640 of file runtime.cc.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DebugPrint
	)

Definition at line 9647 of file runtime.cc.

References ASSERT, HeapObject::cast(), Flush(), HeapObject::map(), PrintF(), and Object::ShortPrint().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DebugTrace
	)

Definition at line 9678 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateCurrentTime
	)

Definition at line 9686 of file runtime.cc.

References ASSERT, and OS::TimeCurrentMillis().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateParseString
	)

Definition at line 9699 of file runtime.cc.

References ASSERT, FixedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, JSObject::EnsureCanContainHeapObjectElements(), FlattenString(), String::FlatContent::IsAscii(), String::FlatContent::IsTwoByte(), FixedArrayBase::length(), DateParser::OUTPUT_SIZE, DateParser::Parse(), RUNTIME_ASSERT, String::FlatContent::ToOneByteVector(), and String::FlatContent::ToUC16Vector().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateLocalTimezone
	)

Definition at line 9736 of file runtime.cc.

References ASSERT, CONVERT_DOUBLE_ARG_CHECKED, and CStrVector().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateToUTC
	)

Definition at line 9747 of file runtime.cc.

References ASSERT, and CONVERT_DOUBLE_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_DateCacheVersion
	)

Definition at line 9758 of file runtime.cc.

References ASSERT, Handle< T >::cast(), EternalHandles::DATE_CACHE_VERSION, Smi::FromInt(), hs, JSArray::SetContent(), and TENURED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GlobalReceiver
	)

Definition at line 9779 of file runtime.cc.

References ASSERT, and JSGlobalObject::cast().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsAttachedGlobal
	)

Definition at line 9788 of file runtime.cc.

References ASSERT, and JSGlobalObject::cast().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ParseJson
	)

Definition at line 9798 of file runtime.cc.

References ASSERT, ASSERT_EQ, CONVERT_ARG_HANDLE_CHECKED, Failure::Exception(), FlattenGetString(), and Handle< T >::is_null().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CompileString
	)

Definition at line 9837 of file runtime.cc.

References ASSERT_EQ, CodeGenerationFromStringsAllowed(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_BOOLEAN_ARG_CHECKED, Compiler::GetFunctionFromEval(), NO_PARSE_RESTRICTION, ONLY_SINGLE_FUNCTION_LITERAL, RETURN_IF_EMPTY_HANDLE, and SLOPPY.

v8::internal::RUNTIME_FUNCTION	(	ObjectPair	,
		RuntimeHidden_ResolvePossiblyDirectEval
	)

Definition at line 9896 of file runtime.cc.

References ASSERT, SLOPPY, and STRICT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_AllocateInNewSpace
	)

Definition at line 9947 of file runtime.cc.

References ASSERT, CONVERT_SMI_ARG_CHECKED, and NEW_SPACE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_AllocateInTargetSpace
	)

Definition at line 9955 of file runtime.cc.

References ASSERT, CONVERT_SMI_ARG_CHECKED, BitFieldBase< bool, shift, size, uint32_t >::decode(), and BitFieldBase< AllocationSpace, shift, size, uint32_t >::decode().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_PushIfAbsent
	)

Definition at line 9969 of file runtime.cc.

References ASSERT, Smi::cast(), FixedArray::cast(), CONVERT_ARG_HANDLE_CHECKED, FixedArray::get(), RETURN_IF_EMPTY_HANDLE, RUNTIME_ASSERT, JSObject::SetFastElement(), and SLOPPY.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ArrayConcat
	)

Array::concat implementation. See ECMAScript 262, 15.4.4.4. TODO(581): Fix non-compliance for very large concatenations and update to following the ECMAScript 5 specification.

Definition at line 10471 of file runtime.cc.

References ASSERT, ASSERT_EQ, Handle< T >::cast(), Smi::cast(), FixedArray::cast(), FixedDoubleArray::cast(), JSArray::cast(), CONVERT_ARG_HANDLE_CHECKED, Map::elements_kind(), ArrayConcatVisitor::exceeds_array_limit(), Failure::Exception(), FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS, FAST_HOLEY_DOUBLE_ELEMENTS, FAST_HOLEY_ELEMENTS, FAST_HOLEY_SMI_ELEMENTS, FAST_SMI_ELEMENTS, Smi::FromInt(), FixedArray::get(), FixedDoubleArray::get_scalar(), JSObject::GetElementsTransitionMap(), GetPackedElementsKind(), ArrayConcatVisitor::increase_index_offset(), FixedDoubleArray::is_the_hole(), IsMoreGeneralElementsKindTransition(), JSObject::kMaxElementCount, map, HeapObject::map(), NULL, Object::Number(), obj, RUNTIME_ASSERT, ArrayConcatVisitor::ToArray(), UNREACHABLE, Smi::value(), and ArrayConcatVisitor::visit().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GlobalPrint
	)

Definition at line 10646 of file runtime.cc.

References ASSERT, CONVERT_ARG_CHECKED, StringCharacterStream::GetNext(), StringCharacterStream::HasMore(), and PrintF().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RemoveArrayHoles
	)

Definition at line 10667 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_NUMBER_CHECKED, and JSObject::PrepareElementsForSort().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MoveArrayContents
	)

Definition at line 10677 of file runtime.cc.

References ASSERT, Map::cast(), CONVERT_ARG_CHECKED, Smi::FromInt(), and obj.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_EstimateNumberOfElements
	)

Definition at line 10703 of file runtime.cc.

References ASSERT, FixedArray::cast(), SeededNumberDictionary::cast(), JSArray::cast(), CONVERT_ARG_CHECKED, Smi::FromInt(), and HashTable< Shape, Key >::NumberOfElements().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetArrayKeys
	)

Definition at line 10724 of file runtime.cc.

References ASSERT, Handle< T >::cast(), JSObject::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_NUMBER_CHECKED, JSObject::HasIndexedInterceptor(), keys(), Min(), NONE, NumberToUint32(), and UnionOfKeys().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_LookupAccessor
	)

Definition at line 10762 of file runtime.cc.

References ACCESSOR_GETTER, ACCESSOR_SETTER, ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, flag, JSObject::GetAccessor(), and RETURN_IF_EMPTY_HANDLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetScript
	)

Definition at line 14451 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_CollectStackTrace
	)

Definition at line 14468 of file runtime.cc.

References ASSERT_EQ, CONVERT_ARG_HANDLE_CHECKED, and CONVERT_NUMBER_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetAndClearOverflowedStackTrace
	)

Definition at line 14484 of file runtime.cc.

References ASSERT_EQ, CONVERT_ARG_HANDLE_CHECKED, JSObject::DeleteHiddenProperty(), and RUNTIME_ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetV8Version
	)

Definition at line 14498 of file runtime.cc.

References ASSERT_EQ, CStrVector(), V8::GetVersion(), and NOT_TENURED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_Abort
	)

Definition at line 14509 of file runtime.cc.

References OS::Abort(), ASSERT, CONVERT_SMI_ARG_CHECKED, GetBailoutReason(), message, NULL, OS::PrintError(), and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_AbortJS
	)

Definition at line 14523 of file runtime.cc.

References OS::Abort(), ASSERT, CONVERT_ARG_HANDLE_CHECKED, message, NULL, OS::PrintError(), and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_FlattenString
	)

Definition at line 14535 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and FlattenString().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_NotifyContextDisposed
	)

Definition at line 14544 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_TryMigrateInstance
	)

Definition at line 14552 of file runtime.cc.

References ASSERT, Handle< T >::cast(), CONVERT_ARG_HANDLE_CHECKED, Smi::FromInt(), and JSObject::TryMigrateInstance().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_GetFromCache
	)

Definition at line 14569 of file runtime.cc.

References ARRAY_SIZE, ASSERT, Execution::Call(), JSFunction::cast(), CONVERT_ARG_CHECKED, Failure::Exception(), JSFunctionResultCache::kEntriesIndex, JSFunctionResultCache::kEntrySize, JSFunctionResultCache::kFactoryIndex, and size.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MessageGetStartPosition
	)

Definition at line 14668 of file runtime.cc.

References CONVERT_ARG_CHECKED, Smi::FromInt(), and message.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MessageGetScript
	)

Definition at line 14675 of file runtime.cc.

References CONVERT_ARG_CHECKED, and message.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_Log
	)

Definition at line 14730 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, and SmartPointerBase< Deallocator, T >::get().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IS_VAR
	)

Definition at line 14743 of file runtime.cc.

References NULL, and UNREACHABLE.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_HaveSameMap
	)

Definition at line 14791 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsAccessCheckNeeded
	)

Definition at line 14800 of file runtime.cc.

References ASSERT, and CONVERT_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsObserved
	)

Definition at line 14808 of file runtime.cc.

References ASSERT, JSReceiver::cast(), JSReceiver::GetPrototype(), Map::is_observed(), and HeapObject::map().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetIsObserved
	)

Definition at line 14824 of file runtime.cc.

References ASSERT, Handle< T >::cast(), JSReceiver::cast(), CONVERT_ARG_HANDLE_CHECKED, Object::GetPrototype(), handle(), and JSObject::SetObserved().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_SetMicrotaskPending
	)

Definition at line 14845 of file runtime.cc.

References ASSERT, and CONVERT_BOOLEAN_ARG_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_RunMicrotasks
	)

Definition at line 14855 of file runtime.cc.

References ASSERT, and Execution::RunMicrotasks().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetMicrotaskState
	)

Definition at line 14864 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_GetObservationState
	)

Definition at line 14871 of file runtime.cc.

References ASSERT.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_ObservationWeakMapCreate
	)

Definition at line 14878 of file runtime.cc.

References ASSERT, Handle< T >::cast(), JS_WEAK_MAP_TYPE, and JSWeakCollection::kSize.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_UnwrapGlobalProxy
	)

Definition at line 14892 of file runtime.cc.

References ASSERT, and Object::GetPrototype().

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_IsAccessAllowedForObserver
	)

Definition at line 14904 of file runtime.cc.

References v8::ACCESS_GET, v8::ACCESS_HAS, v8::ACCESS_KEYS, String::AsArrayIndex(), ASSERT, String::cast(), and CONVERT_ARG_HANDLE_CHECKED.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_ArrayConstructor
	)

Definition at line 15013 of file runtime.cc.

References ASSERT, Handle< T >::cast(), CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		RuntimeHidden_InternalArrayConstructor
	)

Definition at line 15050 of file runtime.cc.

References ASSERT, CONVERT_ARG_HANDLE_CHECKED, CONVERT_SMI_ARG_CHECKED, and NULL.

v8::internal::RUNTIME_FUNCTION	(	MaybeObject *	,
		Runtime_MaxSmi
	)

Definition at line 15073 of file runtime.cc.

References Smi::FromInt(), and Smi::kMaxValue.

int Search ( T *  array, Name *  name, int  valid_entries  )

inline

Definition at line 2510 of file objects-inl.h.

References ALL_ENTRIES, name, SLOW_ASSERT, and VALID_ENTRIES.

Referenced by ConsStringIteratorOp::ContinueOperation().

int v8::internal::SearchString	(	Isolate *	isolate,
		Vector< const SubjectChar >	subject,
		Vector< const PatternChar >	pattern,
		int	start_index
	)

Definition at line 570 of file string-search.h.

References StringSearch< PatternChar, SubjectChar >::Search().

Referenced by RegExpImpl::AtomExecRaw(), and Runtime::StringMatch().

void v8::internal::SeqStringSet ( Handle< StringType >  seq_str, int  i, uc32  c  )

inline

void v8::internal::SeqStringSet ( Handle< SeqTwoByteString >  seq_str, int  i, uc32  c  )

inline

Definition at line 568 of file json-parser.h.

void v8::internal::SeqStringSet ( Handle< SeqOneByteString >  seq_str, int  i, uc32  c  )

inline

Definition at line 573 of file json-parser.h.

void v8::internal::SetExpectedNofPropertiesFromEstimate	(	Handle< SharedFunctionInfo >	shared,
		int	estimate
	)

Definition at line 532 of file compiler.cc.

References Serializer::enabled().

Referenced by Compiler::BuildFunctionInfo().

void SetUpJSCallerSavedCodeData

(

)

Definition at line 1600 of file frames.cc.

References ASSERT, kJSCallerSaved, kNumJSCallerSaved, kNumRegs, and JSCallerSavedCodeData::reg_code.

void v8::internal::SetVersion	(	int	major,
		int	minor,
		int	build,
		int	patch,
		bool	candidate,
		const char *	soname
	)

Definition at line 39 of file test-version.cc.

int32_t v8::internal::signed_bitextract_32 ( int  msb, int  lsb, int32_t  x  )

inline

Definition at line 1092 of file utils.h.

Referenced by Instruction::ImmPCRel(), and Instruction::SignedBits().

int v8::internal::signed_bitextract_64 ( int  msb, int  lsb, int  x  )

inline

Definition at line 1096 of file utils.h.

double v8::internal::SignedZero ( bool  negative )

inline

Definition at line 54 of file conversions-inl.h.

References Double::kSignMask, and uint64_to_double().

Referenced by InternalStringToDouble(), InternalStringToInt(), and InternalStringToIntDouble().

v8::internal::SMI_ACCESSORS	(	ConstantPoolArray	,
		first_code_ptr_index	,
		kFirstCodePointerIndexOffset
	)

kFirstHeapPointerIndexOffset v8::internal::SMI_ACCESSORS	(	ConstantPoolArray	,
		first_int32_index	,
		kFirstInt32IndexOffset
	)

Definition at line 2234 of file objects-inl.h.

int SortedListBSearch	(	const List< T > &	list,
		P	cmp
	)

Definition at line 241 of file list-inl.h.

References T.

Referenced by HeapSnapshot::GetEntryById().

int SortedListBSearch	(	const List< T > &	list,
		T	elem
	)

Definition at line 276 of file list-inl.h.

Operand v8::internal::StackOperandForReturnAddress ( int32_t  disp )

inline

Definition at line 1601 of file macro-assembler-x64.h.

References rsp.

int StackSlotOffset

(

int

index

)

Definition at line 240 of file lithium.cc.

References StandardFrameConstants::kFixedFrameSizeFromFp, kFPOnStackSize, kPCOnStackSize, and kPointerSize.

Referenced by LCodeGen::ToHighMemOperand(), and LCodeGen::ToMemOperand().

Operand v8::internal::StackSpaceOperand ( int  index )

inline

Definition at line 1591 of file macro-assembler-x64.h.

References kPointerSize, and rsp.

const char* v8::internal::StateToString ( StateTag  state )

inline

Definition at line 43 of file vm-state-inl.h.

References COMPILER, EXTERNAL, GC, JS, NULL, OTHER, and UNREACHABLE.

v8::internal::STATIC_ASSERT

(

(static_cast< int32_t >(-1) >> 1)

= =-1

)

v8::internal::STATIC_ASSERT

(

(static_cast< uint32_t >(-1) >> 1)

= =0x7FFFFFFF

)

v8::internal::STATIC_ASSERT

(

NUMBER_OF_CONSTRAINTS<=

8

)

v8::internal::STATIC_ASSERT

(

Token::NUM_TOKENS<=

0x100

)

v8::internal::STATIC_ASSERT

(

STANDARD_STORE

= =0

)

STATIC_ASSERT

(

kGrowICDelta

= =STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT-STORE_TRANSITION_SMI_TO_OBJECT

)

STATIC_ASSERT

(

)

STATIC_ASSERT

(

sizeof(CPURegister)

= =sizeof(Register)

)

Referenced by Heap::AllocateCatchContext(), Heap::AllocateForeign(), Heap::AllocateHeapNumber(), Heap::AllocateSymbol(), RegExpImpl::AtomExec(), BUILTIN(), Map::CanTransition(), InitializeFastElementsKindSequence::Construct(), CopyBytes(), CopyWords(), LCodeGen::DoDeferredTaggedToI(), Assembler::EmitStringData(), V8_FINAL< kOperandKind, kNumCachedOperands >::ForStringLength(), XMMRegister::from_code(), X87Register::FromAllocationIndex(), NormalizedMapCache::Get(), ConstantPoolArray::get_int64_entry_as_double(), String::GetUnderlying(), OperandInitializer< int_t >::immediate_for(), ReplacementStringBuilder::IncrementCharacterCount(), ElementsAccessor::InitializeOncePerProcess(), BASE_EMBEDDED< Visitor >::INLINE(), RegExpImpl::IrregexpExecRaw(), String::IsOneByteRepresentationUnderneath(), String::IsTwoByteRepresentationUnderneath(), CompleteParserRecorder::LogMessage(), MoveWords(), Factory::NewConsString(), GlobalHandles::Node::Node(), Operand::Operand(), PerIsolateAssertScope< type, allow >::PerIsolateAssertScope(), VisitorDispatchTable< ScavengingCallback >::RegisterSpecializations(), RUNTIME_FUNCTION(), SafeStackFrameIterator::SafeStackFrameIterator(), ConstantPoolArray::set(), JSObject::ShouldConvertToSlowElements(), TEST(), UntagSmiMemOperand(), StaticMarkingVisitor< StaticVisitor >::VisitJSFunctionStrongCode(), StaticMarkingVisitor< StaticVisitor >::VisitJSFunctionWeakCode(), and StaticMarkingVisitor< StaticVisitor >::VisitSharedFunctionInfoWeakCode().

v8::internal::STATIC_ASSERT

(

kJSSPCode

= =28

)

v8::internal::STATIC_ASSERT

(

(kSeqStringTag &kIsIndirectStringMask)

= =0

)

v8::internal::STATIC_ASSERT

(

(kExternalStringTag &kIsIndirectStringMask)

= =0

)

v8::internal::STATIC_ASSERT

(

(kConsStringTag &kIsIndirectStringMask)

= =kIsIndirectStringTag

)

v8::internal::STATIC_ASSERT

(

(kSlicedStringTag &kIsIndirectStringMask)

= =kIsIndirectStringTag

)

v8::internal::STATIC_ASSERT

(

IS_POWER_OF_TWO(kSlicedNotConsMask)&&kSlicedNotConsMask!

= 0

)

v8::internal::STATIC_ASSERT

(

DoubleRegister::kMaxNumAllocatableRegisters >=Register::kMaxNumAllocatableRegisters

)

v8::internal::STATIC_ASSERT

(

(FixedDoubleArray::kHeaderSize &kDoubleAlignmentMask)

= =0

)

v8::internal::STATIC_ASSERT

(

(ConstantPoolArray::kHeaderSize &kDoubleAlignmentMask)

= =0

)

v8::internal::STATIC_ASSERT

(

BoyerMoorePositionInfo::kMapSize

= =RegExpMacroAssembler::kTableSize

)

v8::internal::STATIC_CHECK

(

(kStringRepresentationMask|kStringEncodingMask)

= =Internals::kFullStringRepresentationMask

)

Referenced by HeapSnapshot::HeapSnapshot(), and RUNTIME_FUNCTION().

v8::internal::STATIC_CHECK

(

static_cast< uint32_t >

kStringEncodingMask = =Internals::kStringEncodingMask

)

v8::internal::STATIC_CHECK

(

(kExternalStringTag|kOneByteStringTag)

= =Internals::kExternalAsciiRepresentationTag

)

v8::internal::STATIC_CHECK

(

v8::String::ASCII_ENCODING

= =kOneByteStringTag

)

v8::internal::STATIC_CHECK

(

(kExternalStringTag|kTwoByteStringTag)

= =Internals::kExternalTwoByteRepresentationTag

)

v8::internal::STATIC_CHECK

(

v8::String::TWO_BYTE_ENCODING

= =kTwoByteStringTag

)

v8::internal::STATIC_CHECK

(

sizeof(MemoryChunk)<=MemoryChunk::kHeaderSize

)

v8::internal::STATIC_CHECK

(

JS_OBJECT_TYPE

= =Internals::kJSObjectType

)

v8::internal::STATIC_CHECK

(

FIRST_NONSTRING_TYPE

= =Internals::kFirstNonstringType

)

v8::internal::STATIC_CHECK

(

ODDBALL_TYPE

= =Internals::kOddballType

)

v8::internal::STATIC_CHECK

(

FOREIGN_TYPE

= =Internals::kForeignType

)

v8::internal::STATIC_CHECK

(

sizeof(Page)<=MemoryChunk::kHeaderSize

)

v8::internal::STATIC_CHECK

(

sizeof(LargePage)<=MemoryChunk::kHeaderSize

)

bool v8::internal::StoringValueNeedsWriteBarrier ( HValue *  value )

inline

Definition at line 5604 of file hydrogen-instructions.h.

References HValue::type().

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::NeedsWriteBarrier().

char * StrDup

(

const char *

str

)

Definition at line 89 of file allocation.cc.

References OS::MemCopy(), and StrLength().

Referenced by CcTest::CcTest(), DoubleToFixedCString(), main(), ReleaseStackTraceDataTest(), TEST(), and THREADED_TEST().

Handle<String> v8::internal::StringReplaceOneCharWithString	(	Isolate *	isolate,
		Handle< String >	subject,
		Handle< String >	search,
		Handle< String >	replace,
		bool *	found,
		int	recursion_limit
	)

Definition at line 4270 of file runtime.cc.

References ConsString::cast(), Isolate::factory(), ConsString::first(), Handle< T >::is_null(), Factory::NewConsString(), Factory::NewSubString(), Handle< T >::null(), RETURN_IF_EMPTY_HANDLE_VALUE, ConsString::second(), and Runtime::StringMatch().

Referenced by RUNTIME_FUNCTION().

double StringToDouble	(	UnicodeCache *	unicode_cache,
		const char *	str,
		int	flags,
		double	empty_string_val
	)

Definition at line 47 of file conversions.cc.

References InternalStringToDouble(), and StrLength().

Referenced by DuplicateFinder::AddNumber(), Scanner::DoubleValue(), RUNTIME_FUNCTION(), and TEST().

double StringToDouble	(	UnicodeCache *	unicode_cache,
		Vector< const char >	str,
		int	flags,
		double	empty_string_val
	)

Definition at line 58 of file conversions.cc.

References InternalStringToDouble(), Vector< T >::length(), and Vector< T >::start().

double StringToDouble	(	UnicodeCache *	unicode_cache,
		Vector< const uc16 >	str,
		int	flags,
		double	empty_string_val
	)

Definition at line 71 of file conversions.cc.

References flags, InternalStringToDouble(), Vector< T >::length(), and Vector< T >::start().

double StringToDouble	(	UnicodeCache *	unicode_cache,
		String *	str,
		int	flags,
		double	empty_string_val
	)

Definition at line 83 of file v8conversions.cc.

References InternalStringToDouble(), and String::length().

double StringToInt	(	UnicodeCache *	unicode_cache,
		String *	str,
		int	radix
	)

Definition at line 109 of file v8conversions.cc.

References InternalStringToInt(), and String::length().

Referenced by RUNTIME_FUNCTION().

int v8::internal::StrLength ( const char *  string )

inline

Definition at line 253 of file utils.h.

References ASSERT.

Referenced by DuplicateFinder::AddNumber(), SimpleStringBuilder::AddString(), OutputStreamWriter::AddString(), CodeEventLogger::NameBuffer::AppendBytes(), CStrVector(), DEPENDENT_TEST(), DoubleToPrecisionCString(), CpuProfilesCollection::IsLastProfile(), MutableCStrVector(), Object::ObjectProtoToString(), OneByteVector(), ReadLine(), RunParserSyncTest(), CpuProfilesCollection::StopProfiling(), StrDup(), StringToDouble(), StrNDup(), TEST(), THREADED_TEST(), and FileByteSink::WriteSpaceUsed().

char * StrNDup	(	const char *	str,
		int	n
	)

Definition at line 98 of file allocation.cc.

References OS::MemCopy(), and StrLength().

double Strtod	(	Vector< const char >	buffer,
		int	exponent
	)

Definition at line 417 of file strtod.cc.

References Vector< T >::length(), and V8_INFINITY.

Referenced by InternalStringToDouble(), InternalStringToInt(), and TEST().

bool v8::internal::SubStringEquals	(	Iterator *	current,
		EndMark	end,
		const char *	substring
	)

Definition at line 111 of file conversions-inl.h.

References ASSERT.

Referenced by InternalStringToDouble().

enable upcoming ES6 features enable harmony block scoping enable harmony symbols

(

a.k.a.private

names

)

Referenced by DumpBacktrace(), and TEST().

int v8::internal::TenToThe ( int  exponent )

inline

Definition at line 880 of file utils.h.

References ASSERT.

Referenced by StringHasher::MakeArrayIndexHash().

v8::internal::TEST

(

Positions

)

Definition at line 44 of file test-reloc-info.cc.

References CHECK, CHECK_EQ, RelocIterator::done(), SmartPointerBase< ArrayDeallocator< T >, T >::get(), KB, RelocIterator::next(), NULL, and RelocIterator::rinfo().

int v8::internal::ToNumber

(

Register

reg

)

Referenced by MacroAssembler::GetCodeMarker(), and ToNumberStub::InstallDescriptors().

double v8::internal::ToQuietNaN ( double  num )

inline

Definition at line 111 of file utils-arm64.h.

References ASSERT, std::isnan(), and kDQuietNanMask.

float v8::internal::ToQuietNaN ( float  num )

inline

Definition at line 117 of file utils-arm64.h.

References ASSERT, std::isnan(), and kSQuietNanMask.

Register v8::internal::ToRegister

(

int

num

)

void v8::internal::TraceGVN	(	const char *	msg,
			...
	)

Definition at line 121 of file hydrogen-gvn.cc.

References OS::VPrint().

MaybeObject* v8::internal::TransitionElements	(	Handle< Object >	object,
		ElementsKind	to_kind,
		Isolate *	isolate
	)

Definition at line 334 of file runtime.cc.

References Handle< T >::cast(), Map::IsValidElementsTransition(), Isolate::ThrowIllegalOperation(), and JSObject::TransitionElementsKind().

Referenced by Runtime::CreateArrayLiteralBoilerplate(), and RUNTIME_FUNCTION().

T v8::internal::truncate_to_intn ( T  x, unsigned  n  )

inline

Definition at line 1114 of file utils.h.

References ASSERT, and kBitsPerByte.

bool v8::internal::TryNumberToSize ( Isolate *  isolate, Object *  number, size_t *  result  )

inline

Definition at line 76 of file v8conversions.h.

References ASSERT, Smi::cast(), HeapNumber::cast(), Smi::kMaxValue, Smi::value(), and HeapNumber::value().

Referenced by NumberToSize().

double v8::internal::uint64_to_double ( uint64_t  d64 )

inline

Definition at line 38 of file double.h.

Referenced by RUNTIME_FUNCTION(), SignedZero(), TEST(), and Double::value().

Handle< FixedArray > UnionOfKeys	(	Handle< FixedArray >	first,
		Handle< FixedArray >	second
	)

Definition at line 134 of file handles.cc.

References CALL_HEAP_FUNCTION.

Referenced by GetKeysInFixedArrayFor(), and RUNTIME_FUNCTION().

uint32_t v8::internal::unsigned_bitextract_32 ( int  msb, int  lsb, uint32_t  x  )

inline

Definition at line 1084 of file utils.h.

Referenced by Instruction::Bits().

uint64_t v8::internal::unsigned_bitextract_64 ( int  msb, int  lsb, uint64_t  x  )

inline

Definition at line 1088 of file utils.h.

MemOperand UntagSmiFieldMemOperand ( Register  object, int  offset  )

inline

Definition at line 51 of file macro-assembler-arm64-inl.h.

References kHeapObjectTag, and UntagSmiMemOperand().

MemOperand UntagSmiMemOperand ( Register  object, int  offset  )

inline

Definition at line 56 of file macro-assembler-arm64-inl.h.

References kBitsPerByte, kSmiShift, and STATIC_ASSERT().

Referenced by UntagSmiFieldMemOperand().

void v8::internal::USE ( T  )

inline

Definition at line 341 of file globals.h.

Referenced by HOptimizedGraphBuilder::BindIfLive(), Assembler::BitN(), BUILTIN(), ParserBase< ParserTraits >::Consume(), Thread::CreateThreadLocalKey(), Thread::DeleteThreadLocalKey(), DoubleToPrecisionCString(), OS::Free(), MemoryAllocator::FreeMemory(), Deoptimizer::TableEntryGenerator::GeneratePrologue(), OptimizedFrame::GetInlineCount(), GetKeysInFixedArrayFor(), Handle< v8::internal::JSFunction >::Handle(), HeapSnapshot::HeapSnapshot(), Assembler::ImmR(), Assembler::ImmRotate(), Assembler::ImmS(), Assembler::ImmSetBits(), SimulatorStack::JsLimitFromCLimit(), Assembler::LoadPairNonTemporalOpFor(), Assembler::LoadPairOpFor(), HOptimizedGraphBuilder::LookupAndMakeLive(), TypeSwitch::match(), MemsetPointer(), Compiler::RecordFunctionCompilation(), VirtualMemory::Release(), SamplerThread::RemoveActiveSampler(), Scope::ResolveVariable(), V8_FINAL::Run(), RUNTIME_FUNCTION(), Function::SetName(), Thread::SetThreadLocal(), StoreBuffer::SetUp(), Thread::Start(), Assembler::StorePairNonTemporalOpFor(), Assembler::StorePairOpFor(), TEST(), V8_FINAL< kOperandKind, kNumCachedOperands >::Unique(), SharedFunctionInfo::VerifyBailoutId(), CpuFeatures::VerifyCrossCompiling(), VirtualMemory::VirtualMemory(), Thread::YieldCPU(), and VirtualMemory::~VirtualMemory().

v8::internal::V8_DECLARE_ONCE

(

init_once

)

v8::internal::V8_DECLARE_ONCE

(

initialize_gc_once

)

int v8::internal::WhichPowerOf2 ( uint32_t  x )

inline

Definition at line 57 of file utils.h.

References ASSERT, ASSERT_EQ, IsPowerOf2(), and UNREACHABLE.

Referenced by WhichPowerOf2Abs().

int32_t v8::internal::WhichPowerOf2Abs ( int32_t  x )

inline

Definition at line 261 of file utils.h.

References Abs(), kMinInt, and WhichPowerOf2().

int v8::internal::WriteAsCFile	(	const char *	filename,
		const char *	varname,
		const char *	str,
		int	size,
		bool	verbose = true
	)

int WriteBytes	(	const char *	filename,
		const byte *	bytes,
		int	size,
		bool	verbose
	)

Definition at line 248 of file v8utils.cc.

References WriteChars().

int WriteChars	(	const char *	filename,
		const char *	str,
		int	size,
		bool	verbose
	)

Definition at line 231 of file v8utils.cc.

References OS::FOpen(), NULL, OS::PrintError(), and WriteCharsToFile().

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::CodeTracer(), V8_FINAL< kOperandKind, kNumCachedOperands >::HTracer(), and WriteBytes().

int v8::internal::WriteCharsToFile	(	const char *	str,
		int	size,
		FILE *	f
	)

Definition at line 200 of file v8utils.cc.

Referenced by AppendChars(), and WriteChars().

Variable Documentation

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp __v8_gc__

Definition at line 813 of file flags.cc.

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit allows_lazy_compilation

Definition at line 5129 of file objects-inl.h.

Referenced by JSFunction::MarkForConcurrentOptimization(), JSFunction::MarkForOptimization(), and JSFunction::MarkInOptimizationQueue().

const Register arg_reg_1 = { kRegister_rdi_Code }

Definition at line 190 of file assembler-x64.h.

const Register arg_reg_2 = { kRegister_rsi_Code }

Definition at line 191 of file assembler-x64.h.

const Register arg_reg_3 = { kRegister_rdx_Code }

Definition at line 192 of file assembler-x64.h.

const Register arg_reg_4 = { kRegister_rcx_Code }

Definition at line 193 of file assembler-x64.h.

struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures

Definition at line 45 of file atomicops_internals_x86_gcc.h.

ByteArray

Definition at line 4980 of file objects-inl.h.

const int BYTECODE_MASK = 0xff

Definition at line 36 of file bytecodes-irregexp.h.

const int BYTECODE_SHIFT = 8

Definition at line 41 of file bytecodes-irregexp.h.

JSCallerSavedCodeData caller_saved_code_data

Definition at line 1598 of file frames.cc.

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset kStartPositionAndTypeOffset compiler_hints

Definition at line 5129 of file objects-inl.h.

Referenced by BOOL_GETTER().

const Register cp = { kRegister_r7_Code }

Definition at line 48 of file macro-assembler-arm.h.

Referenced by LCodeGen::DoDeferredInstanceMigration(), LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), LCodeGen::DoDeferredNumberTagD(), LCodeGen::DoDeferredNumberTagIU(), GlobalObjectMemOperand(), GlobalObjectOperand(), and TEST_().

const CRegister cr0 = { 0 }

Definition at line 510 of file assembler-arm.h.

const CRegister cr1 = { 1 }

Definition at line 511 of file assembler-arm.h.

const CRegister cr10 = { 10 }

Definition at line 520 of file assembler-arm.h.

const CRegister cr11 = { 11 }

Definition at line 521 of file assembler-arm.h.

const CRegister cr12 = { 12 }

Definition at line 522 of file assembler-arm.h.

const CRegister cr13 = { 13 }

Definition at line 523 of file assembler-arm.h.

const CRegister cr14 = { 14 }

Definition at line 524 of file assembler-arm.h.

const CRegister cr15 = { 15 }

Definition at line 525 of file assembler-arm.h.

const CRegister cr2 = { 2 }

Definition at line 512 of file assembler-arm.h.

const CRegister cr3 = { 3 }

Definition at line 513 of file assembler-arm.h.

const CRegister cr4 = { 4 }

Definition at line 514 of file assembler-arm.h.

const CRegister cr5 = { 5 }

Definition at line 515 of file assembler-arm.h.

const CRegister cr6 = { 6 }

Definition at line 516 of file assembler-arm.h.

const CRegister cr7 = { 7 }

Definition at line 517 of file assembler-arm.h.

const CRegister cr8 = { 8 }

Definition at line 518 of file assembler-arm.h.

const CRegister cr9 = { 9 }

Definition at line 519 of file assembler-arm.h.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 Specify the name of the log file Enable low level linux profiler Enable perf linux tmp Specify the name of the file for fake gc mmap used in ll_prof Time events including external callbacks prof arm64_inst csv

Definition at line 821 of file flags.cc.

const LowDwVfpRegister d0 = { 0 }

Definition at line 430 of file assembler-arm.h.

Referenced by MakeConvertDToIFuncTrampoline(), TEST(), and TEST_().

const LowDwVfpRegister d1 = { 1 }

Definition at line 431 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d10 = { 10 }

Definition at line 440 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d11 = { 11 }

Definition at line 441 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d12 = { 12 }

Definition at line 442 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d13 = { 13 }

Definition at line 443 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d14 = { 14 }

Definition at line 444 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d15 = { 15 }

Definition at line 445 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d16 = { 16 }

Definition at line 446 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d17 = { 17 }

Definition at line 447 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d18 = { 18 }

Definition at line 448 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d19 = { 19 }

Definition at line 449 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d2 = { 2 }

Definition at line 432 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d20 = { 20 }

Definition at line 450 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d21 = { 21 }

Definition at line 451 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d22 = { 22 }

Definition at line 452 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d23 = { 23 }

Definition at line 453 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d24 = { 24 }

Definition at line 454 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d25 = { 25 }

Definition at line 455 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d26 = { 26 }

Definition at line 456 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d27 = { 27 }

Definition at line 457 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d28 = { 28 }

Definition at line 458 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d29 = { 29 }

Definition at line 459 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d3 = { 3 }

Definition at line 433 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d30 = { 30 }

Definition at line 460 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const DwVfpRegister d31 = { 31 }

Definition at line 461 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d4 = { 4 }

Definition at line 434 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d5 = { 5 }

Definition at line 435 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d6 = { 6 }

Definition at line 436 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d7 = { 7 }

Definition at line 437 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d8 = { 8 }

Definition at line 438 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const LowDwVfpRegister d9 = { 9 }

Definition at line 439 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset dependent_code

Definition at line 5047 of file objects-inl.h.

Referenced by Map::AddDependentCode(), Map::AddDependentCompilationInfo(), PropertyCell::AddDependentCompilationInfo(), CompilationInfo::CommitDependencies(), Map::DeprecateTransitionTree(), Map::NotifyLeafMapLayoutChange(), and CompilationInfo::RollbackDependencies().

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset kInternalFieldCountOffset DependentCode

Definition at line 5047 of file objects-inl.h.

const IntelDoubleRegister double_register_0 = { 0 }

Definition at line 178 of file assembler-ia32.h.

const IntelDoubleRegister double_register_1 = { 1 }

Definition at line 179 of file assembler-ia32.h.

const IntelDoubleRegister double_register_2 = { 2 }

Definition at line 180 of file assembler-ia32.h.

const IntelDoubleRegister double_register_3 = { 3 }

Definition at line 181 of file assembler-ia32.h.

const IntelDoubleRegister double_register_4 = { 4 }

Definition at line 182 of file assembler-ia32.h.

const IntelDoubleRegister double_register_5 = { 5 }

Definition at line 183 of file assembler-ia32.h.

const IntelDoubleRegister double_register_6 = { 6 }

Definition at line 184 of file assembler-ia32.h.

const IntelDoubleRegister double_register_7 = { 7 }

Definition at line 185 of file assembler-ia32.h.

const Register eax = { kRegister_eax_Code }

Definition at line 113 of file assembler-ia32.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), and TEST().

const Register ebp = { kRegister_ebp_Code }

Definition at line 118 of file assembler-ia32.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const Register ebx = { kRegister_ebx_Code }

Definition at line 116 of file assembler-ia32.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), and TEST().

const Register ecx = { kRegister_ecx_Code }

Definition at line 114 of file assembler-ia32.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), and TEST().

const Register edi = { kRegister_edi_Code }

Definition at line 120 of file assembler-ia32.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const Register edx = { kRegister_edx_Code }

Definition at line 115 of file assembler-ia32.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for ENABLE_32DREGS_DEFAULT

Definition at line 396 of file flags.cc.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available ENABLE_VFP3_DEFAULT

Definition at line 383 of file flags.cc.

const Register esi = { kRegister_esi_Code }

Definition at line 119 of file assembler-ia32.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const Register esp = { kRegister_esp_Code }

Definition at line 117 of file assembler-ia32.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const FPURegister f0 = { 0 }

Definition at line 277 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f1 = { 1 }

Definition at line 278 of file assembler-mips.h.

Referenced by TEST(), and THREADED_TEST().

const FPURegister f10 = { 10 }

Definition at line 287 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f11 = { 11 }

Definition at line 288 of file assembler-mips.h.

const FPURegister f12 = { 12 }

Definition at line 289 of file assembler-mips.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const FPURegister f13 = { 13 }

Definition at line 290 of file assembler-mips.h.

const FPURegister f14 = { 14 }

Definition at line 291 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f15 = { 15 }

Definition at line 292 of file assembler-mips.h.

const FPURegister f16 = { 16 }

Definition at line 293 of file assembler-mips.h.

const FPURegister f17 = { 17 }

Definition at line 294 of file assembler-mips.h.

const FPURegister f18 = { 18 }

Definition at line 295 of file assembler-mips.h.

const FPURegister f19 = { 19 }

Definition at line 296 of file assembler-mips.h.

const FPURegister f2 = { 2 }

Definition at line 279 of file assembler-mips.h.

Referenced by TEST(), and THREADED_TEST().

const FPURegister f20 = { 20 }

Definition at line 297 of file assembler-mips.h.

const FPURegister f21 = { 21 }

Definition at line 298 of file assembler-mips.h.

const FPURegister f22 = { 22 }

Definition at line 299 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f23 = { 23 }

Definition at line 300 of file assembler-mips.h.

const FPURegister f24 = { 24 }

Definition at line 301 of file assembler-mips.h.

const FPURegister f25 = { 25 }

Definition at line 302 of file assembler-mips.h.

const FPURegister f26 = { 26 }

Definition at line 303 of file assembler-mips.h.

const FPURegister f27 = { 27 }

Definition at line 304 of file assembler-mips.h.

const FPURegister f28 = { 28 }

Definition at line 305 of file assembler-mips.h.

const FPURegister f29 = { 29 }

Definition at line 306 of file assembler-mips.h.

const FPURegister f3 = { 3 }

Definition at line 280 of file assembler-mips.h.

const FPURegister f30 = { 30 }

Definition at line 307 of file assembler-mips.h.

const FPURegister f31 = { 31 }

Definition at line 308 of file assembler-mips.h.

const FPURegister f4 = { 4 }

Definition at line 281 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f5 = { 5 }

Definition at line 282 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f6 = { 6 }

Definition at line 283 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f7 = { 7 }

Definition at line 284 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f8 = { 8 }

Definition at line 285 of file assembler-mips.h.

Referenced by TEST().

const FPURegister f9 = { 9 }

Definition at line 286 of file assembler-mips.h.

trace the creation of allocation sites test secondary stub cache by disabling the primary one print generated code print unoptimized code before printing optimized code based on it false

Definition at line 171 of file flags.cc.

const FPUControlRegister FCSR = { kFCSRRegister }

Definition at line 344 of file assembler-mips.h.

Referenced by TEST().

first_heap_ptr_index

Definition at line 2233 of file objects-inl.h.

Referenced by ConstantPoolArray::OffsetOfElementAt().

kInstanceClassNameOffset kNeedsAccessCheckBit flag

Definition at line 5115 of file objects-inl.h.

Referenced by AccessorInfo::all_can_read(), AccessorInfo::all_can_write(), StubCache::ComputeLoadNonexistent(), StubCache::ComputeMonomorphicIC(), JSArrayBuffer::is_external(), AccessorInfo::prohibits_overwriting(), AccessorInfo::property_attributes(), RUNTIME_FUNCTION(), AccessorInfo::set_all_can_read(), AccessorInfo::set_all_can_write(), JSArrayBuffer::set_is_external(), Variable::set_is_used(), AccessorInfo::set_prohibits_overwriting(), AccessorInfo::set_property_attributes(), JSArrayBuffer::set_should_be_freed(), JSArrayBuffer::should_be_freed(), and THREADED_TEST().

const bool FLAG_enable_slow_asserts = false

Definition at line 307 of file checks.h.

Referenced by ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::AddElementsToFixedArray(), FixedArray::AddKeysFromJSArray(), Context::AddOptimizedFunction(), NormalizedMapCache::Get(), String::MakeExternal(), MacroAssembler::SmiUntag(), MacroAssembler::SmiUntagToDouble(), MacroAssembler::SmiUntagToFloat(), FixedArray::UnionOfKeys(), and JSObject::ValidateElements().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including flags

Definition at line 665 of file flags.cc.

Referenced by ACCESSORS_TO_SMI(), DuplicateFinder::AddNumber(), TypeFeedbackOracle::AssignmentReceiverTypes(), CodeStubGraphBuilder< Stub >::BuildCodeInitializedStub(), LChunk::Codegen(), Script::compilation_state(), ScopeInfo::Create(), LCodeGen::DoDeferredInstanceOfKnownGlobal(), PlatformCodeStub::GenerateCode(), HydrogenCodeStub::GenerateLightweightMissCode(), CodeCacheHashTableKey::IsMatch(), CodeCache::Lookup(), FullCodeGenerator::MakeCode(), CodeCacheHashTableKey::NameFlagsHashHelper(), TypeFeedbackOracle::PropertyReceiverTypes(), HStoreEliminationPhase::Run(), RUNTIME_FUNCTION(), Script::set_compilation_state(), Script::set_compilation_type(), StringToDouble(), IC::TryRemoveInvalidPrototypeDependentStub(), and HOptimizedGraphBuilder::VisitDeclarations().

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments formal_parameter_count

Definition at line 5190 of file objects-inl.h.

const Register fp = { kRegister_fp_Code }

Definition at line 240 of file assembler-arm.h.

Referenced by StandardFrame::caller_fp(), StandardFrame::caller_pc(), ExitFrame::code_slot(), StandardFrame::ComputeCallerState(), StandardFrame::ComputeExpressionsCount(), JavaScriptFrame::ComputeOperandsCount(), StandardFrame::context(), LCodeGen::DoDeferredNumberTagD(), LCodeGen::DoDeferredNumberTagIU(), TraceExtension::DoTrace(), ExitFrame::FillState(), ExitFrame::GetCallerStackPointer(), JavaScriptFrame::GetCallerStackPointer(), StubFrame::GetCallerStackPointer(), ArgumentsAdaptorFrame::GetCallerStackPointer(), InternalFrame::GetCallerStackPointer(), StubFailureTrampolineFrame::GetCallerStackPointer(), StandardFrame::GetExpressionAddress(), JavaScriptFrame::GetOperandSlot(), StubFailureTrampolineFrame::Iterate(), StandardFrame::IterateCompiledFrame(), StandardFrame::IterateExpressions(), OS::LogSharedLibraryAddresses(), JavaScriptFrame::RestoreOperandStack(), SafeStackFrameIterator::SafeStackFrameIterator(), EntryFrame::SetCallerFp(), ExitFrame::SetCallerFp(), StandardFrame::SetCallerFp(), FrameDescription::SetFp(), TEST(), TEST_(), LCodeGen::ToHighMemOperand(), LCodeGen::ToMemOperand(), InternalFrame::unchecked_code(), BASE_EMBEDDED< Visitor >::UpdateFp(), and FileByteSink::WriteSpaceUsed().

const int GB = KB * KB * KB

Definition at line 247 of file globals.h.

Referenced by ResourceConstraints::ConfigureDefaults().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag Hello

Definition at line 636 of file flags.cc.

const int ImmPCRel_mask = ImmPCRelLo_mask | ImmPCRelHi_mask

Definition at line 259 of file constants-arm64.h.

kSerializedDataOffset kPrototypeTemplateOffset indexed_property_handler

Definition at line 5021 of file objects-inl.h.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function info

Definition at line 317 of file flags.cc.

Referenced by BasicHeapEntriesAllocator::AllocateEntry(), Heap::AllocateTypeFeedbackInfo(), AllocationTracker::AllocationTracker(), HGraphBuilder::BuildBinaryOperation(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), Compiler::BuildFunctionInfo(), FunctionCallbackArguments::Call(), TypeFeedbackOracle::CallNewIsMonomorphic(), TypeFeedbackOracle::CompareType(), LoadIC::CompileHandler(), StoreIC::CompileHandler(), Compiler::CompileScript(), ModuleInfo::Create(), Factory::CreateApiFunction(), SeqRegExpNode::FilterASCII(), TextNode::FilterASCII(), ChoiceNode::FilterASCII(), NegativeLookaheadChoiceNode::FilterASCII(), LoopChoiceNode::FilterASCII(), LCodeGen::FinishCode(), TypeFeedbackOracle::GetCallNewAllocationSite(), TypeFeedbackOracle::GetCallNewTarget(), TypeFeedbackOracle::GetCallTarget(), Compiler::GetCodeForDebugging(), Compiler::GetConcurrentlyOptimizedCode(), BASE_EMBEDDED< Visitor >::GetEntry(), Compiler::GetFunctionFromEval(), Compiler::GetOptimizedCode(), LoopChoiceNode::GetQuickCheckDetails(), Compiler::GetUnoptimizedCode(), BASE_EMBEDDED< Visitor >::isolate(), NativeObjectsExplorer::IterateAndExtractReferences(), Accessors::MakeModuleExport(), V8_FINAL< kOperandKind, kNumCachedOperands >::MarkDependsOnEmptyArrayProtoElements(), LCodeGen::NeedsDeferredFrame(), LCodeGen::NeedsEagerFrame(), Factory::NewDeclaredAccessorInfo(), Factory::NewExecutableAccessorInfo(), IC::PostPatching(), AllocationTraceNode::Print(), GlobalHandles::RemoveObjectGroups(), BoyerMooreLookahead::Set(), BoyerMooreLookahead::SetInterval(), TEST(), LCodeGen::WriteTranslation(), and NativeObjectsExplorer::~NativeObjectsExplorer().

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset instance_call_handler

Definition at line 5027 of file objects-inl.h.

instance_class_name

Definition at line 5102 of file objects-inl.h.

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset internal_field_count

Definition at line 5034 of file objects-inl.h.

Referenced by Factory::CreateApiFunction(), and ObjectTemplate::InternalFieldCount().

const Register ip = { kRegister_ip_Code }

Definition at line 241 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), LCodeGen::DoDeferredTaggedToI(), LCodeGen::EmitLoadDoubleRegister(), generate(), Deoptimizer::TableEntryGenerator::GeneratePrologue(), MakeConvertDToIFuncTrampoline(), TEST(), and MacroAssembler::TrySmiTag().

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit is_expression

Definition at line 5123 of file objects-inl.h.

const Instr kAddSubFlip

Definition at line 472 of file constants-arm.h.

const int kAlignmentPaddingPushed = 2

Definition at line 57 of file frames-ia32.h.

const int kAlignmentZapValue = 0x12345678

Definition at line 58 of file frames-ia32.h.

const Instr kAndBicFlip

Definition at line 473 of file constants-arm.h.

const int kApiIntSize = sizeof(int)

Definition at line 5470 of file v8.h.

const int kApiPointerSize = sizeof(void*)

Definition at line 5469 of file v8.h.

Referenced by Object::GetAlignedPointerFromInternalField(), Internals::GetEmbedderData(), Object::GetInternalField(), Internals::GetRoot(), Internals::ReadEmbedderData(), and Internals::SetEmbedderData().

const int KB = 1024

Definition at line 245 of file globals.h.

Referenced by Heap::AdjustAmountOfExternalAllocatedMemory(), Heap::ConfigureHeapDefault(), Deoptimizer::EnsureCodeForDeoptimizationEntry(), FullCodeGenerator::MakeCode(), Heap::PrepareForCompare(), Heap::PrintShortHeapStatistics(), Builtins::SetUp(), PagedSpace::SizeOfFirstPage(), TEST(), and TEST().

const int kBArgsSlotsSize = 0 * Instruction::kInstrSize

Definition at line 814 of file constants-mips.h.

const int kBase10MaximalLength = 17

Definition at line 50 of file dtoa.h.

Referenced by DoubleToCString(), and DoubleToExponentialCString().

const int kBinary32ExponentBias = 127

Definition at line 296 of file globals.h.

const uint32_t kBinary32ExponentMask = 0x7f800000u

Definition at line 294 of file globals.h.

const int kBinary32ExponentShift = 23

Definition at line 300 of file globals.h.

const int kBinary32MantissaBits = 23

Definition at line 299 of file globals.h.

const uint32_t kBinary32MantissaMask = 0x007fffffu

Definition at line 295 of file globals.h.

const int kBinary32MaxExponent = 0xFE

Definition at line 297 of file globals.h.

const int kBinary32MinExponent = 0x01

Definition at line 298 of file globals.h.

const uint32_t kBinary32SignMask = 0x80000000u

Definition at line 293 of file globals.h.

const int kBitfieldNOffset = 22

Definition at line 592 of file constants-arm64.h.

const int kBitsPerByte = 8

Definition at line 287 of file globals.h.

Referenced by CPURegister::Bit(), is_uintn(), StandardFrame::IterateCompiledFrame(), CPURegList::RegisterSizeInBytes(), truncate_to_intn(), and UntagSmiMemOperand().

const int kBitsPerByteLog2 = 3

Definition at line 288 of file globals.h.

Referenced by StandardFrame::IterateCompiledFrame().

const int kBitsPerInt = kIntSize * kBitsPerByte

Definition at line 290 of file globals.h.

Referenced by BUILTIN().

const int kBitsPerPointer = kPointerSize * kBitsPerByte

Definition at line 289 of file globals.h.

const Instr kBlxIp

const Instr kBlxRegMask

Definition at line 457 of file constants-arm.h.

const Instr kBlxRegPattern

Definition at line 459 of file constants-arm.h.

const int kBranchReturnOffset = 2 * Instruction::kInstrSize

Definition at line 816 of file constants-mips.h.

const int64_t kByteMask = 0xffL

Definition at line 100 of file constants-arm64.h.

const unsigned kByteSize = 8

Definition at line 116 of file constants-arm64.h.

const unsigned kByteSizeInBytes = kByteSize >> 3

Definition at line 117 of file constants-arm64.h.

const RegList kCalleeSaved

Initial value:

=
  1 <<  4 |  
  1 <<  5 |  
  1 <<  6 |  
  1 <<  7 |  
  1 <<  8 |  
  kR9Available <<  9 |  
  1 << 10 |  
  1 << 11

Definition at line 63 of file frames-arm.h.

Referenced by MakeConvertDToIFuncTrampoline().

const RegList kCalleeSavedFPU

Initial value:

=
  1 << 20 |  
  1 << 22 |  
  1 << 24 |  
  1 << 26 |  
  1 << 28 |  
  1 << 30

Definition at line 79 of file frames-mips.h.

const RegList kCallerSaved

Initial value:

=
  1 <<  0 |  
  1 <<  1 |  
  1 <<  2 |  
  1 <<  3 |  
  1 <<  9

Definition at line 75 of file frames-arm.h.

const RegList kCallerSavedFPU

Initial value:

=
  1 << 0  |  
  1 << 2  |  
  1 << 4  |  
  1 << 6  |  
  1 << 8  |  
  1 << 10 |  
  1 << 12 |  
  1 << 14 |  
  1 << 16 |  
  1 << 18

Definition at line 89 of file frames-mips.h.

const int kCArgSlotCount = 4

Definition at line 809 of file constants-mips.h.

Referenced by CFunctionArgumentOperand().

const int kCArgsSlotsSize = kCArgSlotCount * Instruction::kInstrSize

Definition at line 810 of file constants-mips.h.

Referenced by CFunctionArgumentOperand().

const int kCharSize = sizeof(char)

Definition at line 261 of file globals.h.

Referenced by SimpleStringBuilder::AddSubstring(), ByteArray::get(), Object::ObjectProtoToString(), ReadLine(), SeqOneByteString::SeqOneByteStringGet(), SeqOneByteString::SeqOneByteStringSet(), ByteArray::set(), and SeqOneByteString::SizeFor().

const int kChunkBits = 7

Definition at line 337 of file assembler.cc.

const int kChunkMask = (1 << kChunkBits) - 1

Definition at line 338 of file assembler.cc.

const Instr kCmpCmnFlip

Definition at line 471 of file constants-arm.h.

const Instr kCmpCmnMask

Definition at line 469 of file constants-arm.h.

const Instr kCmpCmnPattern

Definition at line 470 of file constants-arm.h.

const int kCodeAgeJumpInstruction = 0xe51ff004

Definition at line 54 of file constants-arm.h.

const intptr_t kCodeAlignment = 1 << kCodeAlignmentBits

Definition at line 58 of file v8globals.h.

Referenced by Heap::CreateCode(), Space::RoundSizeDownToObjectAlignment(), and Code::SizeFor().

const int kCodeAlignmentBits = 5

Definition at line 57 of file v8globals.h.

const intptr_t kCodeAlignmentMask = kCodeAlignment - 1

Definition at line 59 of file v8globals.h.

const int kCodeTargetTag = 1

Definition at line 326 of file assembler.cc.

Referenced by RelocIterator::next().

const int kCodeWithIdTag = 0

Definition at line 346 of file assembler.cc.

Referenced by RelocIterator::next().

const int kCodeZapValue = 0xbadc0de

Definition at line 91 of file v8globals.h.

Referenced by FreeList::Allocate().

const int kCommentTag = 3

Definition at line 349 of file assembler.cc.

Referenced by RelocIterator::next().

const int kConstantPoolLengthMaxMask = 0xffff

Definition at line 43 of file constants-arm.h.

Referenced by EncodeConstantPoolLength().

const int kConstantPoolMarker = 0xe7f000f0

Definition at line 42 of file constants-arm.h.

Referenced by DecodeConstantPoolLength().

const int kConstantPoolMarkerMask = 0xfff000f0

Definition at line 41 of file constants-arm.h.

Referenced by DecodeConstantPoolLength().

const int kConstPoolTag = 0

Definition at line 352 of file assembler.cc.

Referenced by RelocIterator::next().

const int kCounterNameMaxLength = 256

Definition at line 39 of file instrument-arm64.h.

Referenced by Counter::Counter().

const int kDataJumpExtraTag = kPCJumpExtraTag - 1

Definition at line 344 of file assembler.cc.

Referenced by RelocIterator::next().

const unsigned kDebugCodeOffset = 1 * kInstructionSize

Definition at line 453 of file instructions-arm64.h.

const unsigned kDebuggerTracingDirectivesMask = 3 << 6

Definition at line 478 of file instructions-arm64.h.

const int kDebugIdShift = kDebugRegisterBits

Definition at line 61 of file serialize.h.

const unsigned kDebugMessageOffset = 3 * kInstructionSize

Definition at line 455 of file instructions-arm64.h.

const unsigned kDebugParamsOffset = 2 * kInstructionSize

Definition at line 454 of file instructions-arm64.h.

const int kDebugRegisterBits = 4

Definition at line 60 of file serialize.h.

const uint32_t kDebugZapValue = 0xbadbaddb

Definition at line 87 of file v8globals.h.

const uint64_t kDefaultInstrumentationSamplingPeriod = 1 << 22

Definition at line 40 of file instrument-arm64.h.

const int32_t kDefaultStopCode = -1

Definition at line 366 of file constants-arm.h.

const int kDefaultTag = 3

Definition at line 328 of file assembler.cc.

Referenced by RelocIterator::next().

const int kDeoptTableSerializeEntryCount = 12

Definition at line 63 of file serialize.h.

Referenced by Isolate::Init().

const intptr_t kDoubleAlignment = 8

Definition at line 52 of file v8globals.h.

const intptr_t kDoubleAlignmentMask = kDoubleAlignment - 1

Definition at line 53 of file v8globals.h.

const unsigned kDoubleExponentBits = 11

Definition at line 132 of file constants-arm64.h.

const unsigned kDoubleMantissaBits = 52

Definition at line 131 of file constants-arm64.h.

const int kDoubleSize = sizeof(double)

Definition at line 266 of file globals.h.

Referenced by HGraphBuilder::BuildAllocateElements(), HGraphBuilder::BuildNewSpaceArrayCheck(), Assembler::EndBlockConstPool(), ConstantPoolArray::get_int64_entry_as_double(), FixedDoubleArray::get_representation(), FixedDoubleArray::get_scalar(), FixedDoubleArray::is_the_hole(), StandardFrame::IterateCompiledFrame(), MakeConvertDToIFuncTrampoline(), FixedDoubleArray::set(), ConstantPoolArray::set(), LChunk::set_allocated_double_registers(), FixedDoubleArray::set_the_hole(), and FixedDoubleArray::SizeFor().

const int kDoubleSizeLog2 = 3

Definition at line 273 of file globals.h.

Referenced by BASE_EMBEDDED< Visitor >::INLINE().

const int kDoubleToCStringMinBufferSize = 100

Definition at line 138 of file conversions.h.

const unsigned kDoubleWordSize = 64

Definition at line 126 of file constants-arm64.h.

const unsigned kDoubleWordSizeInBytes = kDoubleWordSize >> 3

Definition at line 127 of file constants-arm64.h.

const int64_t kDQuietNanBit = 51

Definition at line 96 of file constants-arm64.h.

const int64_t kDQuietNanMask = 0x1L << kDQuietNanBit

Definition at line 97 of file constants-arm64.h.

Referenced by IsSignallingNaN(), and ToQuietNaN().

const int64_t kDRegMask = 0xffffffffffffffffL

Definition at line 85 of file constants-arm64.h.

const unsigned kDRegSize = kDRegSizeInBits >> 3

Definition at line 80 of file constants-arm64.h.

Referenced by RegisterDump::Dump().

const unsigned kDRegSizeInBits = 64

Definition at line 78 of file constants-arm64.h.

Referenced by ClobberFP(), FPRegister::DRegFromCode(), FPRegister::from_code(), CPURegister::IsValidFPRegister(), MacroAssembler::PopDRegList(), PopulateFPRegisterArray(), MacroAssembler::PushDRegList(), and TEST().

const unsigned kDRegSizeInBitsLog2 = 6

Definition at line 79 of file constants-arm64.h.

const unsigned kDRegSizeLog2 = kDRegSizeInBitsLog2 - 3

Definition at line 81 of file constants-arm64.h.

const int64_t kDSignBit = 63

Definition at line 88 of file constants-arm64.h.

const int64_t kDSignMask = 0x1L << kDSignBit

Definition at line 89 of file constants-arm64.h.

Referenced by TEST().

const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1

Definition at line 89 of file elements-kind.h.

Referenced by ElementsAccessor::ForKind(), ElementsAccessor::InitializeOncePerProcess(), and Map::set_elements_kind().

const int kEmbeddedObjectTag = 0

Definition at line 325 of file assembler.cc.

Referenced by RelocIterator::next().

const int kExternalArrayTypeCount

Initial value:

=
    LAST_EXTERNAL_ARRAY_TYPE - FIRST_EXTERNAL_ARRAY_TYPE + 1

Definition at line 854 of file objects.h.

const int kExtraTagBits = 4

Definition at line 321 of file assembler.cc.

const int kFailureTag = 3

Definition at line 62 of file v8globals.h.

Referenced by IndexedReferencesExtractor::MarkVisitedField(), MemoryChunk::owner(), and MemoryChunk::set_owner().

const intptr_t kFailureTagMask = (1 << kFailureTagSize) - 1

Definition at line 64 of file v8globals.h.

Referenced by MemoryChunk::owner(), and MemoryChunk::set_owner().

const int kFailureTagSize = 2

Definition at line 63 of file v8globals.h.

const int kFailureTypeTagMask = (1 << kFailureTypeTagSize) - 1

Definition at line 1713 of file objects.h.

Referenced by Failure::type().

const int kFailureTypeTagSize = 2

Definition at line 1712 of file objects.h.

Referenced by Failure::allocation_space().

const int kFastDtoaMaximalLength = 17

Definition at line 46 of file fast-dtoa.h.

Referenced by TEST().

const int kFastElementsKindCount

Initial value:

= LAST_FAST_ELEMENTS_KIND -
    FIRST_FAST_ELEMENTS_KIND + 1

Definition at line 90 of file elements-kind.h.

Referenced by InitializeFastElementsKindSequence::Construct(), GetFastElementsKindFromSequenceIndex(), and GetSequenceIndexFromFastElementsKind().

const int kFastElementsKindPackedToHoley

Initial value:

=
    FAST_HOLEY_SMI_ELEMENTS - FAST_SMI_ELEMENTS

Definition at line 94 of file elements-kind.h.

Referenced by InitializeFastElementsKindSequence::Construct().

const int kFBccBits = 3

Definition at line 241 of file constants-mips.h.

Referenced by Instruction::FBccValue().

const int kFBccShift = 18

Definition at line 240 of file constants-mips.h.

Referenced by Instruction::FBccValue().

const int kFBtrueBits = 1

Definition at line 243 of file constants-mips.h.

Referenced by Instruction::FBtrueValue().

const int kFBtrueShift = 16

Definition at line 242 of file constants-mips.h.

Referenced by Instruction::FBtrueValue().

const int kFCccBits = 3

Definition at line 239 of file constants-mips.h.

Referenced by Instruction::FCccValue().

const int kFCccShift = 8

Definition at line 238 of file constants-mips.h.

Referenced by Instruction::FCccValue().

const uint32_t kFCSRDivideByZeroFlagBit = 5

Definition at line 109 of file constants-mips.h.

const uint32_t kFCSRDivideByZeroFlagMask = 1 << kFCSRDivideByZeroFlagBit

Definition at line 115 of file constants-mips.h.

const uint32_t kFCSRExceptionFlagMask = kFCSRFlagMask ^ kFCSRInexactFlagMask

Definition at line 125 of file constants-mips.h.

const uint32_t kFCSRFlagMask

Initial value:

=
    kFCSRInexactFlagMask |
    kFCSRUnderflowFlagMask |
    kFCSROverflowFlagMask |
    kFCSRDivideByZeroFlagMask |
    kFCSRInvalidOpFlagMask

Definition at line 118 of file constants-mips.h.

const uint32_t kFCSRInexactFlagBit = 2

Definition at line 106 of file constants-mips.h.

const uint32_t kFCSRInexactFlagMask = 1 << kFCSRInexactFlagBit

Definition at line 112 of file constants-mips.h.

const uint32_t kFCSRInvalidOpFlagBit = 6

Definition at line 110 of file constants-mips.h.

const uint32_t kFCSRInvalidOpFlagMask = 1 << kFCSRInvalidOpFlagBit

Definition at line 116 of file constants-mips.h.

const uint32_t kFCSROverflowFlagBit = 4

Definition at line 108 of file constants-mips.h.

const uint32_t kFCSROverflowFlagMask = 1 << kFCSROverflowFlagBit

Definition at line 114 of file constants-mips.h.

const int kFCSRRegister = 31

Definition at line 101 of file constants-mips.h.

Referenced by FPUControlRegister::is_valid().

const uint32_t kFCSRUnderflowFlagBit = 3

Definition at line 107 of file constants-mips.h.

const uint32_t kFCSRUnderflowFlagMask = 1 << kFCSRUnderflowFlagBit

Definition at line 113 of file constants-mips.h.

const int kFdBits = 5

Definition at line 237 of file constants-mips.h.

Referenced by Instruction::FdValue().

const int kFdShift = 6

Definition at line 236 of file constants-mips.h.

Referenced by Instruction::FdValue().

const int kFirstCalleeSavedFPRegisterIndex = 8

Definition at line 62 of file constants-arm64.h.

const int kFirstCalleeSavedRegisterIndex = 19

Definition at line 59 of file constants-arm64.h.

const int kFirstTypeCode = UNCLASSIFIED

Definition at line 55 of file serialize.h.

Referenced by ExternalReferenceDecoder::ExternalReferenceDecoder(), and ExternalReferenceDecoder::~ExternalReferenceDecoder().

const unsigned kFloatExponentBits = 8

Definition at line 134 of file constants-arm64.h.

const unsigned kFloatMantissaBits = 23

Definition at line 133 of file constants-arm64.h.

const int kFPOnStackSize = kRegisterSize

Definition at line 271 of file globals.h.

Referenced by StackSlotOffset().

const uint32_t kFPUInvalidResult = static_cast<uint32_t>(1 << 31) - 1

Definition at line 103 of file constants-mips.h.

const uint32_t kFPURoundingModeMask = 3 << 0

Definition at line 562 of file constants-mips.h.

const unsigned kFramePointerRegCode = 29

Definition at line 109 of file constants-arm64.h.

Referenced by TEST().

const int kFrBits = 5

Definition at line 230 of file constants-mips.h.

Referenced by Instruction::FrValue().

const uint32_t kFreeListZapValue = 0xfeed1eaf

Definition at line 88 of file v8globals.h.

const Address kFromSpaceZapValue = reinterpret_cast<Address>(0xbeefdaf)

Definition at line 85 of file v8globals.h.

const int kFrShift = 21

Definition at line 231 of file constants-mips.h.

Referenced by Instruction::FrValue().

const int kFsBits = 5

Definition at line 233 of file constants-mips.h.

Referenced by Instruction::FsValue().

const int kFsShift = 11

Definition at line 232 of file constants-mips.h.

Referenced by Instruction::FsValue().

const int kFtBits = 5

Definition at line 235 of file constants-mips.h.

Referenced by Instruction::FtValue().

const int kFtShift = 16

Definition at line 234 of file constants-mips.h.

Referenced by Instruction::FtValue().

const int kFunctionBits = 6

Definition at line 216 of file constants-mips.h.

Referenced by Instruction::FunctionValue().

const int kFunctionFieldMask = ((1 << kFunctionBits) - 1) << kFunctionShift

Definition at line 255 of file constants-mips.h.

Referenced by Instruction::FunctionFieldRaw().

const int kFunctionShift = 0

Definition at line 215 of file constants-mips.h.

Referenced by Instruction::FunctionValue().

const Address kGlobalHandleZapValue = reinterpret_cast<Address>(0xbaffedf)

Definition at line 84 of file v8globals.h.

Referenced by GlobalHandles::Node::Release().

const int64_t kHalfWordMask = 0xffffL

Definition at line 101 of file constants-arm64.h.

const unsigned kHalfWordSize = 16

Definition at line 118 of file constants-arm64.h.

const unsigned kHalfWordSizeInBytes = kHalfWordSize >> 3

Definition at line 120 of file constants-arm64.h.

const unsigned kHalfWordSizeInBytesLog2 = kHalfWordSizeLog2 - 3

Definition at line 121 of file constants-arm64.h.

const unsigned kHalfWordSizeLog2 = 4

Definition at line 119 of file constants-arm64.h.

const int kHandleBlockSize = v8::internal::KB - 2

Definition at line 616 of file api.h.

Referenced by DeferredHandleScope::DeferredHandleScope(), HandleScopeImplementer::DeleteExtensions(), HandleScopeImplementer::GetSpareOrNewBlock(), and HandleScope::NumberOfHandles().

const Address kHandleZapValue = reinterpret_cast<Address>(0xbaddeaf)

Definition at line 83 of file v8globals.h.

Referenced by CustomArguments< PropertyCallbackInfo< Value > >::~CustomArguments().

const int kHeapObjectTag = 1

Definition at line 5473 of file v8.h.

Referenced by HeapObject::address(), LCodeGen::DoDeferredNumberTagD(), LCodeGen::DoDeferredNumberTagIU(), LCodeGen::DoDeferredTaggedToI(), FieldMemOperand(), FieldOperand(), Heap::FinalizeExternalString(), HeapObject::FromAddress(), ByteArray::FromDataStartAddress(), ByteArray::GetDataStartAddress(), Internals::HasHeapObjectTag(), Internals::ReadField(), MacroAssembler::RecordWriteContextSlot(), SeqTwoByteString::SeqTwoByteStringGetData(), SemiSpace::SetUp(), NewSpace::SetUp(), Context::SlotOffset(), TEST(), and UntagSmiFieldMemOperand().

const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1

Definition at line 5475 of file v8.h.

Referenced by Internals::HasHeapObjectTag(), HeapObjectTagMask(), SemiSpace::SetUp(), and NewSpace::SetUp().

const int kHeapObjectTagSize = 2

Definition at line 5474 of file v8.h.

const int kHiMask = 0xffff << 16

Definition at line 257 of file constants-mips.h.

const int kHltBadCode = 0xbad

Definition at line 708 of file constants-arm64.h.

const uint64_t kHoleNanInt64

Initial value:

=
    (static_cast<uint64_t>(kHoleNanUpper32) << 32) | kHoleNanLower32

Definition at line 458 of file v8globals.h.

Referenced by FixedDoubleArray::canonical_not_the_hole_nan_as_double(), FixedDoubleArray::hole_nan_as_double(), FixedDoubleArray::is_the_hole_nan(), and TEST().

const uint32_t kHoleNanLower32 = 0xFFFFFFFF

Definition at line 455 of file v8globals.h.

const uint32_t kHoleNanUpper32 = 0x7FFFFFFF

Definition at line 454 of file v8globals.h.

Referenced by FixedDoubleArray::canonical_not_the_hole_nan_as_double().

const int kImm16Bits = 16

Definition at line 220 of file constants-mips.h.

Referenced by Instruction::Imm16Value().

const int kImm16Shift = 0

Definition at line 219 of file constants-mips.h.

Referenced by Instruction::Imm16Value().

const int kImm26Bits = 26

Definition at line 222 of file constants-mips.h.

Referenced by Instruction::Imm26Value().

const int kImm26Mask = ((1 << kImm26Bits) - 1) << kImm26Shift

Definition at line 249 of file constants-mips.h.

const int kImm26Shift = 0

Definition at line 221 of file constants-mips.h.

Referenced by Instruction::Imm26Value().

const int kImm28Bits = 28

Definition at line 224 of file constants-mips.h.

const int kImm28Mask = ((1 << kImm28Bits) - 1) << kImm28Shift

Definition at line 250 of file constants-mips.h.

const int kImm28Shift = 0

Definition at line 223 of file constants-mips.h.

const Instr kImmExceptionIsDebug = 0xdeb0

Definition at line 445 of file instructions-arm64.h.

Referenced by TEST_().

const Instr kImmExceptionIsPrintf = 0xdeb1

Definition at line 424 of file instructions-arm64.h.

const Instr kImmExceptionIsRedirectedCall = 0xca11

Definition at line 416 of file instructions-arm64.h.

const Instr kImmExceptionIsUnreachable = 0xdebf

Definition at line 420 of file instructions-arm64.h.

const int kImmFieldShift = 2

Definition at line 228 of file constants-mips.h.

const unsigned kInstructionSize = 4

Definition at line 49 of file constants-arm64.h.

Referenced by Assembler::EmitStringData(), Instruction::following(), Instruction::ImmBranchRange(), Instruction::InstructionAtOffset(), Assembler::InstructionsGeneratedSince(), RecordWriteStub::Patch(), and TEST().

const unsigned kInstructionSizeLog2 = 2

Definition at line 50 of file constants-arm64.h.

Referenced by Instruction::ImmBranchRange(), and RecordWriteStub::Patch().

const int kInt32Size = sizeof(int32_t)

Definition at line 264 of file globals.h.

Referenced by Assembler::RelocInfoNone(), and Assembler::repmovsl().

const int kInt64Size = sizeof(int64_t)

Definition at line 265 of file globals.h.

Referenced by ConstantPoolArray::get_int64_entry_as_double(), Assembler::RelocInfoNone(), Assembler::repmovsq(), and ConstantPoolArray::set().

const uint32_t kInternalizedTag = 0x0

Definition at line 605 of file objects.h.

const intptr_t kIntptrSignBit = 0x80000000

Definition at line 282 of file globals.h.

const int kIntptrSize = sizeof(intptr_t)

Definition at line 267 of file globals.h.

Referenced by RelocIterator::next().

const int kIntSize = sizeof(int)

Definition at line 263 of file globals.h.

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::ForHeapNumberValueHighestBits(), ByteArray::get_int(), Code::set_back_edge_table_offset(), Name::set_hash_field(), Code::set_safepoint_table_offset(), and TEST().

const int kInvalidFPUControlRegister = -1

Definition at line 102 of file constants-mips.h.

const int kInvalidFPURegister = -1

Definition at line 98 of file constants-mips.h.

const int kInvalidRegister = -1

Definition at line 88 of file constants-mips.h.

const bool kIs64BitArch = false

Definition at line 284 of file globals.h.

const uint32_t kIsIndirectStringMask = 0x1

Definition at line 622 of file objects.h.

Referenced by String::IsOneByteRepresentationUnderneath(), String::IsTwoByteRepresentationUnderneath(), and Heap::TargetSpaceId().

const uint32_t kIsIndirectStringTag = 0x1

Definition at line 623 of file objects.h.

Referenced by String::IsOneByteRepresentationUnderneath(), String::IsTwoByteRepresentationUnderneath(), and Heap::TargetSpaceId().

const uint32_t kIsNotInternalizedMask = 0x40

Definition at line 603 of file objects.h.

const uint32_t kIsNotStringMask = 0x80

Definition at line 597 of file objects.h.

Referenced by MacroAssembler::IsObjectJSStringType(), and MacroAssembler::IsObjectStringType().

const int kJSArgsSlotsSize = 0 * Instruction::kInstrSize

Definition at line 812 of file constants-mips.h.

const unsigned kJSCalleeSavedRegList = 0x03f80000

Definition at line 64 of file constants-arm64.h.

const RegList kJSCallerSaved

Initial value:

=
  1 << 0 |  
  1 << 1 |  
  1 << 2 |  
  1 << 3

Definition at line 47 of file frames-arm.h.

Referenced by SetUpJSCallerSavedCodeData().

const unsigned kJSSPCode = 28

Definition at line 112 of file constants-arm64.h.

Referenced by TEST().

const int kJumpAddrMask = (1 << (kImm26Bits + kImmFieldShift)) - 1

Definition at line 260 of file constants-mips.h.

const int kLastChunkTag = 1

Definition at line 341 of file assembler.cc.

const int kLastChunkTagBits = 1

Definition at line 339 of file assembler.cc.

const int kLastChunkTagMask = 1

Definition at line 340 of file assembler.cc.

const uint64_t kLastNonNaNInt64

Initial value:

=
    (static_cast<uint64_t>(kNaNOrInfinityLowerBoundUpper32) << 32)

Definition at line 460 of file v8globals.h.

const Instr kLdrPCMask

Definition at line 451 of file constants-arm.h.

const Instr kLdrPCPattern

Definition at line 452 of file constants-arm.h.

const Instr kLdrPpMask

const Instr kLdrPpPattern

const Instr kLdrRegFpNegOffsetPattern

const Instr kLdrRegFpOffsetPattern

const Instr kLdrStrInstrArgumentMask

const Instr kLdrStrInstrTypeMask

const Instr kLdrStrOffsetMask

const unsigned kLinkRegCode = 30

Definition at line 110 of file constants-arm64.h.

Referenced by TEST().

const unsigned kLiteralEntrySize = 4

Definition at line 51 of file constants-arm64.h.

const unsigned kLiteralEntrySizeLog2 = 2

Definition at line 52 of file constants-arm64.h.

Referenced by Instruction::LiteralAddress().

const int kLocatableTag = 2

Definition at line 327 of file assembler.cc.

Referenced by RelocIterator::next().

const int kLocatableTypeTagBits = 2

Definition at line 322 of file assembler.cc.

const int kLoMask = 0xffff

Definition at line 258 of file constants-mips.h.

const int kLuiShift = 16

Definition at line 217 of file constants-mips.h.

const Instr kLwRegFpNegOffsetPattern

const Instr kLwRegFpOffsetPattern

const Instr kLwSwInstrArgumentMask

const Instr kLwSwInstrTypeMask

const Instr kLwSwOffsetMask

const int kMaxInt = 0x7FFFFFFF

Definition at line 248 of file globals.h.

Referenced by BUILTIN(), V8_FINAL< kOperandKind, kNumCachedOperands >::CopyClearUpper(), ReplacementStringBuilder::IncrementCharacterCount(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsMostGeneric(), LifetimePosition::MaxPosition(), Heap::PromotedTotalSize(), RUNTIME_FUNCTION(), PagedSpace::SlowAllocateRaw(), Code::SourcePosition(), Assembler::StartBlockConstPool(), TEST(), and String::ToCString().

const int kMaxInt16 = (1 << 15) - 1

Definition at line 254 of file globals.h.

const int kMaxInt8 = (1 << 7) - 1

Definition at line 250 of file globals.h.

const int kMaxKeyedPolymorphism = 4

Definition at line 37 of file ic.h.

Referenced by KeyedLoadIC::LoadElementStub(), and KeyedStoreIC::StoreElementStub().

const unsigned kMaxLoadLiteralRange = 1 * MB

Definition at line 53 of file constants-arm64.h.

const int kMaxLookaheadForBoyerMoore = 8

Definition at line 139 of file jsregexp.cc.

Referenced by ChoiceNode::Emit().

const int kMaxSignificantDigits = 772

Definition at line 45 of file conversions.h.

Referenced by InternalStringToDouble(), and InternalStringToInt().

const uint32_t kMaxStopCode = kStopCode - 1

Definition at line 365 of file constants-arm.h.

const int kMaxUInt16 = (1 << 16) - 1

Definition at line 256 of file globals.h.

const uint32_t kMaxUInt32 = 0xFFFFFFFFu

Definition at line 259 of file globals.h.

Referenced by FastFixedDtoa(), Value::IsUint32(), and JSObject::PrepareSlowElementsForSort().

const int kMaxUInt8 = (1 << 8) - 1

Definition at line 252 of file globals.h.

const uint32_t kMaxWatchpointCode = 31

Definition at line 199 of file constants-mips.h.

const int kMinInt = -kMaxInt - 1

Definition at line 249 of file globals.h.

Referenced by V8_FINAL< kOperandKind, kNumCachedOperands >::CopyClearLower(), IntToCString(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsMostGeneric(), TEST(), and WhichPowerOf2Abs().

const int kMinInt16 = -(1 << 15)

Definition at line 255 of file globals.h.

const int kMinInt8 = -(1 << 7)

Definition at line 251 of file globals.h.

const int kMinUInt16 = 0

Definition at line 257 of file globals.h.

const int kMinUInt8 = 0

Definition at line 253 of file globals.h.

const Instr kMovLeaveCCMask

Definition at line 464 of file constants-arm.h.

const Instr kMovLeaveCCPattern

Definition at line 465 of file constants-arm.h.

const Instr kMovLrPc

Definition at line 449 of file constants-arm.h.

const Instr kMovMvnFlip

Definition at line 463 of file constants-arm.h.

const Instr kMovMvnMask

Definition at line 461 of file constants-arm.h.

const Instr kMovMvnPattern

Definition at line 462 of file constants-arm.h.

const Instr kMovwLeaveCCFlip

Definition at line 468 of file constants-arm.h.

const Instr kMovwMask

Definition at line 466 of file constants-arm.h.

const Instr kMovwPattern

Definition at line 467 of file constants-arm.h.

const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000

Definition at line 456 of file v8globals.h.

const int kNoAlignmentPadding = 0

Definition at line 56 of file frames-ia32.h.

const int kNonstatementPositionTag = 1

Definition at line 347 of file assembler.cc.

Referenced by RelocIterator::next().

const int kNoRegister = -1

Definition at line 66 of file constants-arm.h.

const uint32_t kNotInternalizedTag = 0x40

Definition at line 604 of file objects.h.

const uint32_t kNotStringTag = 0x80

Definition at line 599 of file objects.h.

Referenced by KeyedLoadStubCompiler::CompileElementHandlers().

const int kNumberOfCalleeSavedFPRegisters = 8

Definition at line 61 of file constants-arm64.h.

const int kNumberOfCalleeSavedRegisters = 11

Definition at line 58 of file constants-arm64.h.

const unsigned kNumberOfFPRegisters = 32

Definition at line 56 of file constants-arm64.h.

Referenced by ClobberFP(), CPURegList::CPURegList(), FPRegister::DRegFromCode(), RegisterDump::Dump(), EqualRegisters(), CPURegister::IsValidFPRegister(), PopulateFPRegisterArray(), and FPRegister::SRegFromCode().

const unsigned kNumberOfRegisters = 32

Definition at line 55 of file constants-arm64.h.

Referenced by Clobber(), CPURegList::CPURegList(), RegisterDump::Dump(), EqualRegisters(), CPURegister::IsValidRegister(), PopulateRegisterArray(), Register::WRegFromCode(), and Register::XRegFromCode().

const int kNumCalleeSaved = 7 + kR9Available

Definition at line 83 of file frames-arm.h.

const int kNumCalleeSavedFPU = 6

Definition at line 87 of file frames-mips.h.

const int kNumDoubleCalleeSaved = 8

Definition at line 86 of file frames-arm.h.

const int kNumFPURegisters = 32

Definition at line 97 of file constants-mips.h.

const int kNumJSCallerSaved = 4

Definition at line 53 of file frames-arm.h.

Referenced by JSCallerSavedCode(), and SetUpJSCallerSavedCodeData().

const int kNumRegisters = 16

Definition at line 57 of file constants-arm.h.

Referenced by RegExpImpl::AtomExec().

const int kNumRegs = 16

Definition at line 43 of file frames-arm.h.

Referenced by SetUpJSCallerSavedCodeData().

const int kNumSafepointRegisters = 16

Definition at line 92 of file frames-arm.h.

Referenced by StandardFrame::IterateCompiledFrame().

const int kNumSafepointSavedRegisters = kNumJSCallerSaved + kNumCalleeSaved

Definition at line 98 of file frames-arm.h.

const int kNumSimuRegisters = 35

Definition at line 91 of file constants-mips.h.

const int kNumVFPDoubleRegisters = 32

Definition at line 61 of file constants-arm.h.

const int kNumVFPRegisters = kNumVFPSingleRegisters + kNumVFPDoubleRegisters

Definition at line 62 of file constants-arm.h.

const int kNumVFPSingleRegisters = 32

Definition at line 60 of file constants-arm.h.

const intptr_t kObjectAlignment = 1 << kObjectAlignmentBits

Definition at line 44 of file v8globals.h.

Referenced by Code::body_size(), Heap::CopyCode(), and Heap::CreateCode().

const int kObjectAlignmentBits = kPointerSizeLog2

Definition at line 43 of file v8globals.h.

Referenced by Serializer::ObjectSerializer::Serialize(), and Serializer::SerializeReferenceToPreviousObject().

const intptr_t kObjectAlignmentMask = kObjectAlignment - 1

Definition at line 45 of file v8globals.h.

Referenced by HGraphBuilder::BuildObjectSizeAlignment(), and HGraphBuilder::BuildUncheckedStringAdd().

const uint32_t kOneByteDataHintMask = 0x08

Definition at line 638 of file objects.h.

Referenced by HGraphBuilder::BuildCreateConsString(), and String::HasOnlyOneByteChars().

const uint32_t kOneByteDataHintTag = 0x08

Definition at line 639 of file objects.h.

Referenced by HGraphBuilder::BuildCreateConsString(), and String::HasOnlyOneByteChars().

const int kOneByteSize = kCharSize

Definition at line 311 of file globals.h.

Referenced by LiteralBuffer::INLINE().

const uint32_t kOneByteStringTag = 0x4

Definition at line 611 of file objects.h.

Referenced by HGraphBuilder::BuildCreateConsString(), HGraphBuilder::BuildUncheckedStringAdd(), String::GetFlatContent(), StaticVisitorBase::GetVisitorId(), String::IsOneByteRepresentation(), String::IsOneByteRepresentationUnderneath(), String::IsTwoByteRepresentationUnderneath(), HeapObject::IterateBody(), String::Visit(), and String::WriteToFlat().

const int kOpcodeBits = 6

Definition at line 206 of file constants-mips.h.

Referenced by Instruction::OpcodeValue().

const int kOpcodeMask = ((1 << kOpcodeBits) - 1) << kOpcodeShift

Definition at line 247 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), and Instruction::OpcodeFieldRaw().

const int kOpcodeShift = 26

Definition at line 205 of file constants-mips.h.

Referenced by Instruction::OpcodeValue().

const int kPageSizeBits = 20

Definition at line 95 of file v8globals.h.

Referenced by MarkCompactCollector::CollectEvacuationCandidates().

const int kPatternTooShortForBoyerMoore = 2

Definition at line 142 of file jsregexp.cc.

const int kPCJumpExtraTag = (1 << kExtraTagBits) - 1

Definition at line 330 of file assembler.cc.

Referenced by RelocIterator::next().

const int kPCOnStackSize = kRegisterSize

Definition at line 270 of file globals.h.

Referenced by ExitFrame::FillState(), and StackSlotOffset().

const int kPCRegister = 15

Definition at line 65 of file constants-arm.h.

const intptr_t kPointerAlignment = (1 << kPointerSizeLog2)

Definition at line 48 of file v8globals.h.

Referenced by SmallPointerList< v8::internal::Map * >::Add(), and SmallPointerList< v8::internal::Map * >::Reserve().

const intptr_t kPointerAlignmentMask = kPointerAlignment - 1

Definition at line 49 of file v8globals.h.

const int kPointerSize = sizeof(void*)

Definition at line 268 of file globals.h.

Referenced by SkipList::AddObject(), BASE_EMBEDDED< Visitor >::Advance(), zone_allocator< T >::allocate(), FreeList::Allocate(), Heap::AllocateConstantPoolArray(), Heap::AllocateFixedTypedArray(), IncrementalMarking::BlackToGreyAndUnshift(), HGraphBuilder::BuildAllocateElements(), HGraphBuilder::BuildArrayBufferViewInitialization(), HGraphBuilder::BuildCloneShallowArray(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), HGraphBuilder::BuildNewSpaceArrayCheck(), SharedFunctionInfo::CalculateInObjectProperties(), SharedFunctionInfo::CalculateInstanceSize(), CFunctionArgumentOperand(), LoadIC::CompileHandler(), StandardFrame::ComputeExpressionsCount(), JavaScriptFrame::ComputeOperandsCount(), ResourceConstraints::ConfigureDefaults(), Heap::CopyBlock(), Heap::CopyFixedArrayWithMap(), Factory::CopyMap(), Map::CopyNormalized(), CopyWords(), Factory::CreateApiFunction(), LCodeGen::DoDeferredInstanceOfKnownGlobal(), Assembler::EndBlockConstPool(), RegExpStack::EnsureCapacity(), StoreBuffer::EnsureSpace(), JSObject::FastPropertyAtPut(), FixedArrayElementOperand(), FrameDescription::FrameDescription(), FixedArray::get(), NormalizedMapCache::Get(), StandardFrame::GetExpressionAddress(), FrameDescription::GetExpressionCount(), Map::GetInObjectPropertyOffset(), JSObject::GetInternalField(), JSObject::GetInternalFieldCount(), JSObject::GetInternalFieldOffset(), JavaScriptFrame::GetOperandSlot(), JavaScriptFrame::GetParameterSlot(), StaticVisitorBase::GetVisitorIdForSize(), PromotionQueue::Initialize(), JSObject::InitializeBody(), Struct::InitializeBody(), JSProxy::InitializeBody(), Page::INLINE(), NewSpace::INLINE(), Heap::IterateAndMarkPointersToFromSpace(), StandardFrame::IterateCompiledFrame(), MacroAssembler::LoadFromSafepointRegisterSlot(), MakeConvertDToIFuncTrampoline(), MarkCompactCollector::MigrateObject(), Heap::MoveBlock(), Heap::MoveElements(), MoveWords(), Zone::New(), FreeListNode::next(), FreeListNode::next_address(), FixedArray::NoIncrementalWriteBarrierSet(), FixedArray::NoWriteBarrierSet(), LoadFieldStub::offset(), JSBuiltinsObject::OffsetOfCodeWithId(), JSBuiltinsObject::OffsetOfFunctionWithId(), FrameDescription::operator new(), BASE_EMBEDDED< Visitor >::operator[](), LChunk::ParameterAt(), MacroAssembler::pop(), MacroAssembler::Pop(), Assembler::pop(), MacroAssembler::PrepareCEntryArgs(), MacroAssembler::push(), MacroAssembler::Push(), JSObject::RawFastPropertyAt(), VisitorDispatchTable< ScavengingCallback >::RegisterSpecialization(), Assembler::RelocInfoNone(), Assembler::repmovsp(), Space::RoundSizeDownToObjectAlignment(), RUNTIME_FUNCTION(), Serializer::ObjectSerializer::Serialize(), FixedArray::set(), LChunk::set_allocated_double_registers(), Map::set_instance_size(), AllocationSite::set_memento_found_count(), FreeListNode::set_next(), FixedArray::set_null(), ExternalAsciiString::set_resource(), FreeListNode::set_size(), FixedArray::set_the_hole(), FixedArray::set_undefined(), JSObject::SetInternalField(), StoreBuffer::SetUp(), Representation::size(), FixedArray::SizeFor(), ConstantPoolArray::SizeFor(), PagedSpace::SizeOfFirstPage(), Context::SlotOffset(), StackSlotOffset(), StackSpaceOperand(), MacroAssembler::StoreToSafepointRegisterSlot(), TEST(), LCodeGen::ToHighMemOperand(), PropertyIndex::translate(), Heap::UpdateAllocationSiteFeedback(), Serializer::ObjectSerializer::VisitCodeEntry(), Serializer::ObjectSerializer::VisitExternalReference(), StaticMarkingVisitor< StaticVisitor >::VisitJSFunctionStrongCode(), StaticMarkingVisitor< StaticVisitor >::VisitJSFunctionWeakCode(), Serializer::VisitPointers(), Serializer::ObjectSerializer::VisitPointers(), StaticMarkingVisitor< StaticVisitor >::VisitSharedFunctionInfoWeakCode(), MarkCompactMarkingVisitor::VisitWeakCollection(), and MemoryAllocator::ZapBlock().

const int kPointerSizeLog2 = 2

Definition at line 281 of file globals.h.

Referenced by MemoryChunk::AddressToMarkbitIndex(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), HGraphBuilder::BuildRegExpConstructResult(), StoreBuffer::Compact(), JavaScriptFrame::ComputeOperandsCount(), Factory::CopyMap(), ElementsKindToShiftSize(), MemoryChunk::FastAddressToMarkbitIndex(), JSObject::GetInternalFieldCount(), StaticVisitorBase::GetVisitorIdForSize(), BASE_EMBEDDED< Visitor >::INLINE(), NewSpace::INLINE(), Map::instance_size(), MemoryChunk::MarkbitIndexToAddress(), and Map::set_instance_size().

const int kPoolExtraTag = kPCJumpExtraTag - 2

Definition at line 351 of file assembler.cc.

Referenced by RelocIterator::next().

const Instr kPopInstruction

Definition at line 593 of file constants-mips.h.

const Instr kPopRegPattern

Definition at line 599 of file constants-mips.h.

const int32_t kPrefHintLoad = 0

Definition at line 128 of file constants-mips.h.

const int32_t kPrefHintLoadRetained = 6

Definition at line 132 of file constants-mips.h.

const int32_t kPrefHintLoadStreamed = 4

Definition at line 130 of file constants-mips.h.

const int32_t kPrefHintPrepareForStore = 30

Definition at line 135 of file constants-mips.h.

const int32_t kPrefHintStore = 1

Definition at line 129 of file constants-mips.h.

const int32_t kPrefHintStoreRetained = 7

Definition at line 133 of file constants-mips.h.

const int32_t kPrefHintStoreStreamed = 5

Definition at line 131 of file constants-mips.h.

const int32_t kPrefHintWritebackInvalidate = 25

Definition at line 134 of file constants-mips.h.

const unsigned kPrintfLength = 2 * kInstructionSize

Definition at line 442 of file instructions-arm64.h.

const unsigned kPrintfTypeOffset = 1 * kInstructionSize

Definition at line 441 of file instructions-arm64.h.

const Instr kPushInstruction

const Instr kPushRegPattern

Definition at line 597 of file constants-mips.h.

const unsigned kQuadWordSize = 128

Definition at line 128 of file constants-arm64.h.

const unsigned kQuadWordSizeInBytes = kQuadWordSize >> 3

Definition at line 129 of file constants-arm64.h.

const uint32_t kQuietNaNHighBitsMask = 0xfff << (51 - 32)

Definition at line 104 of file v8globals.h.

const uint64_t kQuietNaNMask = static_cast<uint64_t>(0xfff) << 51

Definition at line 304 of file globals.h.

Referenced by JunkStringValue().

const int kR9Available = 1

Definition at line 38 of file frames-arm.h.

const int kRdBits = 5

Definition at line 212 of file constants-mips.h.

Referenced by Instruction::RdValue().

const int kRdFieldMask = ((1 << kRdBits) - 1) << kRdShift

Definition at line 253 of file constants-mips.h.

Referenced by Instruction::RdFieldRaw().

const int kRdShift = 11

Definition at line 211 of file constants-mips.h.

Referenced by Instruction::RdValue().

const int kReferenceIdBits = 16

Definition at line 57 of file serialize.h.

const int kReferenceIdMask = (1 << kReferenceIdBits) - 1

Definition at line 58 of file serialize.h.

const int kReferenceTypeShift = kReferenceIdBits

Definition at line 59 of file serialize.h.

const unsigned kRegCodeMask = 0x1f

Definition at line 114 of file constants-arm64.h.

Referenced by Assembler::RdSP(), and Assembler::RnSP().

const int kRegister_eax_Code = 0

Definition at line 103 of file assembler-ia32.h.

const int kRegister_ebp_Code = 5

Definition at line 108 of file assembler-ia32.h.

const int kRegister_ebx_Code = 3

Definition at line 106 of file assembler-ia32.h.

const int kRegister_ecx_Code = 1

Definition at line 104 of file assembler-ia32.h.

const int kRegister_edi_Code = 7

Definition at line 110 of file assembler-ia32.h.

const int kRegister_edx_Code = 2

Definition at line 105 of file assembler-ia32.h.

const int kRegister_esi_Code = 6

Definition at line 109 of file assembler-ia32.h.

const int kRegister_esp_Code = 4

Definition at line 107 of file assembler-ia32.h.

const int kRegister_fp_Code = 11

Definition at line 154 of file assembler-arm.h.

const int kRegister_ip_Code = 12

Definition at line 155 of file assembler-arm.h.

const int kRegister_lr_Code = 14

Definition at line 157 of file assembler-arm.h.

const int kRegister_no_reg_Code = -1

Definition at line 142 of file assembler-arm.h.

const int kRegister_pc_Code = 15

Definition at line 158 of file assembler-arm.h.

const int kRegister_r0_Code = 0

Definition at line 143 of file assembler-arm.h.

const int kRegister_r10_Code = 10

Definition at line 153 of file assembler-arm.h.

const int kRegister_r11_Code = 11

Definition at line 157 of file assembler-x64.h.

const int kRegister_r12_Code = 12

Definition at line 158 of file assembler-x64.h.

const int kRegister_r13_Code = 13

Definition at line 159 of file assembler-x64.h.

const int kRegister_r14_Code = 14

Definition at line 160 of file assembler-x64.h.

const int kRegister_r15_Code = 15

Definition at line 161 of file assembler-x64.h.

const int kRegister_r1_Code = 1

Definition at line 144 of file assembler-arm.h.

const int kRegister_r2_Code = 2

Definition at line 145 of file assembler-arm.h.

const int kRegister_r3_Code = 3

Definition at line 146 of file assembler-arm.h.

const int kRegister_r4_Code = 4

Definition at line 147 of file assembler-arm.h.

const int kRegister_r5_Code = 5

Definition at line 148 of file assembler-arm.h.

const int kRegister_r6_Code = 6

Definition at line 149 of file assembler-arm.h.

const int kRegister_r7_Code = 7

Definition at line 150 of file assembler-arm.h.

const int kRegister_r8_Code = 8

Definition at line 151 of file assembler-arm.h.

const int kRegister_r9_Code = 9

Definition at line 152 of file assembler-arm.h.

const int kRegister_rax_Code = 0

Definition at line 146 of file assembler-x64.h.

const int kRegister_rbp_Code = 5

Definition at line 151 of file assembler-x64.h.

const int kRegister_rbx_Code = 3

Definition at line 149 of file assembler-x64.h.

const int kRegister_rcx_Code = 1

Definition at line 147 of file assembler-x64.h.

const int kRegister_rdi_Code = 7

Definition at line 153 of file assembler-x64.h.

const int kRegister_rdx_Code = 2

Definition at line 148 of file assembler-x64.h.

const int kRegister_rsi_Code = 6

Definition at line 152 of file assembler-x64.h.

const int kRegister_rsp_Code = 4

Definition at line 150 of file assembler-x64.h.

const int kRegister_sp_Code = 13

Definition at line 156 of file assembler-arm.h.

const int kRegisterSize = kPointerSize

Definition at line 269 of file globals.h.

const Register kRootRegister = { kRegister_r10_Code }

Definition at line 50 of file macro-assembler-arm.h.

Referenced by generate(), and MacroAssembler::InitializeRootRegister().

const int kRootRegisterBias = 128

Definition at line 48 of file macro-assembler-x64.h.

Referenced by MacroAssembler::InitializeRootRegister().

const int kRsBits = 5

Definition at line 208 of file constants-mips.h.

Referenced by Instruction::RsValue().

const int kRsFieldMask = ((1 << kRsBits) - 1) << kRsShift

Definition at line 251 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), Instruction::RsFieldRaw(), and Instruction::RsFieldRawNoAssert().

const int kRsShift = 21

Definition at line 207 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), RecordWriteStub::PatchBranchIntoNop(), RecordWriteStub::PatchNopIntoBranch(), and Instruction::RsValue().

const int kRtBits = 5

Definition at line 210 of file constants-mips.h.

Referenced by Instruction::RtValue().

const int kRtFieldMask = ((1 << kRtBits) - 1) << kRtShift

Definition at line 252 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), and Instruction::RtFieldRaw().

const Instr kRtMask

const int kRtShift = 16

Definition at line 209 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), RecordWriteStub::PatchBranchIntoNop(), RecordWriteStub::PatchNopIntoBranch(), and Instruction::RtValue().

const int kSaBits = 5

Definition at line 214 of file constants-mips.h.

Referenced by Instruction::SaValue().

const int kSafepointRegisterStackIndexMap[kNumRegs]

Definition at line 117 of file frames-mips.h.

const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved

Definition at line 97 of file frames-arm.h.

const int kSaFieldMask = ((1 << kSaBits) - 1) << kSaShift

Definition at line 254 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), and Instruction::SaFieldRaw().

const int kSaShift = 6

Definition at line 213 of file constants-mips.h.

Referenced by MacroAssembler::GetCodeMarker(), and Instruction::SaValue().

const Register kScratchRegister = { 10 }

Definition at line 41 of file macro-assembler-x64.h.

const int kSFOffset = 31

Definition at line 448 of file constants-arm64.h.

const uint32_t kShortcutTypeMask

Initial value:

=
    kIsNotStringMask |
    kIsNotInternalizedMask |
    kStringRepresentationMask

Definition at line 652 of file objects.h.

const uint32_t kShortcutTypeTag = kConsStringTag | kNotInternalizedTag

Definition at line 656 of file objects.h.

const uint32_t kShortExternalStringMask = 0x10

Definition at line 643 of file objects.h.

Referenced by ExternalString::is_short().

const uint32_t kShortExternalStringTag = 0x10

Definition at line 644 of file objects.h.

Referenced by ExternalString::is_short().

const int kShortSize = sizeof(short)

Definition at line 262 of file globals.h.

Referenced by SeqTwoByteString::SeqTwoByteStringGet(), SeqTwoByteString::SeqTwoByteStringSet(), and SeqTwoByteString::SizeFor().

const int kSignMask = 0x80000000

Definition at line 259 of file constants-mips.h.

const uint32_t kSlicedNotConsMask = kSlicedStringTag & ~kConsStringTag

Definition at line 633 of file objects.h.

const uint32_t kSlotsZapValue = 0xbeefdeef

Definition at line 86 of file v8globals.h.

const int kSmallDataBits = kBitsPerByte - kLocatableTypeTagBits

Definition at line 323 of file assembler.cc.

const int kSmallPCDeltaBits = kBitsPerByte - kTagBits

Definition at line 332 of file assembler.cc.

const int kSmallPCDeltaMask = (1 << kSmallPCDeltaBits) - 1

Definition at line 333 of file assembler.cc.

const Register kSmiConstantRegister = { 12 }

Definition at line 42 of file macro-assembler-x64.h.

Referenced by MacroAssembler::InitializeSmiConstantRegister().

const int kSmiConstantRegisterValue = 1

Definition at line 45 of file macro-assembler-x64.h.

Referenced by MacroAssembler::InitializeSmiConstantRegister().

const int kSmiShift = kSmiTagSize + kSmiShiftSize

Definition at line 620 of file assembler-arm64.h.

Referenced by Operand::UntagSmi(), Operand::UntagSmiAndScale(), and UntagSmiMemOperand().

const uint64_t kSmiShiftMask = (1UL << kSmiShift) - 1

Definition at line 621 of file assembler-arm64.h.

const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize

Definition at line 5539 of file v8.h.

Referenced by Smi::FromIntptr(), IntToSmi(), SmiTagging< 4 >::SmiToInt(), and SmiTagging< 8 >::SmiToInt().

const intptr_t kSmiSignMask = kIntptrSignBit

Definition at line 41 of file v8globals.h.

Referenced by MacroAssembler::NonNegativeSmiTst().

const int kSmiTag = 0

Definition at line 5478 of file v8.h.

Referenced by Smi::FromIntptr(), BASE_EMBEDDED< Visitor >::INLINE(), IntToSmi(), MacroAssembler::JumpIfBothSmi(), MacroAssembler::JumpIfEitherSmi(), MacroAssembler::JumpIfSmi(), Heap::SetStackLimits(), MacroAssembler::SmiTag(), and MacroAssembler::SmiUntag().

const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1

Definition at line 5480 of file v8.h.

Referenced by LCodeGen::DoDeferredInstanceMigration(), MacroAssembler::JumpIfNotSmi(), MacroAssembler::JumpIfSmi(), Object::NonFailureIsHeapObject(), MacroAssembler::NonNegativeSmiTst(), Heap::SetStackLimits(), MacroAssembler::SmiTst(), TEST(), and TestSelectNonSmi().

const int kSmiTagSize = 1

Definition at line 5479 of file v8.h.

Referenced by MacroAssembler::DecodeField(), Smi::FromIntptr(), BASE_EMBEDDED< Visitor >::INLINE(), IntToSmi(), MacroAssembler::JumpIfBothSmi(), MacroAssembler::JumpIfEitherSmi(), MacroAssembler::JumpIfSmi(), MakeConvertDToIFuncTrampoline(), MacroAssembler::SmiTag(), SmiTagging< 4 >::SmiToInt(), SmiTagging< 8 >::SmiToInt(), and MacroAssembler::SmiUntag().

const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize

Definition at line 5540 of file v8.h.

Referenced by RUNTIME_FUNCTION(), TestSmiShiftArithmeticRight(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), and Operand::UntagSmiAndScale().

const int kSpaceTagMask = (1 << kSpaceTagSize) - 1

Definition at line 194 of file v8globals.h.

Referenced by Failure::allocation_space(), and Failure::RetryAfterGC().

const int kSpaceTagSize = 3

Definition at line 193 of file v8globals.h.

const unsigned kSPRegInternalCode = 63

Definition at line 113 of file constants-arm64.h.

Referenced by CPURegister::IsSP(), CPURegister::IsValidRegister(), Assembler::Ra(), Assembler::Rd(), Assembler::Rm(), Assembler::Rn(), Assembler::Rt(), Assembler::Rt2(), TEST(), RegisterDump::wreg(), and RegisterDump::xreg().

const int64_t kSQuietNanBit = 22

Definition at line 98 of file constants-arm64.h.

const int64_t kSQuietNanMask = 0x1L << kSQuietNanBit

Definition at line 99 of file constants-arm64.h.

Referenced by IsSignallingNaN(), and ToQuietNaN().

const int64_t kSRegMask = 0x00000000ffffffffL

Definition at line 84 of file constants-arm64.h.

const unsigned kSRegSize = kSRegSizeInBits >> 3

Definition at line 76 of file constants-arm64.h.

Referenced by RegisterDump::Dump().

const unsigned kSRegSizeInBits = 32

Definition at line 74 of file constants-arm64.h.

Referenced by CPURegister::IsValidFPRegister(), MacroAssembler::PopSRegList(), PopulateFPRegisterArray(), MacroAssembler::PushSRegList(), FPRegister::SRegFromCode(), and TEST().

const unsigned kSRegSizeInBitsLog2 = 5

Definition at line 75 of file constants-arm64.h.

const unsigned kSRegSizeLog2 = kSRegSizeInBitsLog2 - 3

Definition at line 77 of file constants-arm64.h.

const int64_t kSSignBit = 31

Definition at line 90 of file constants-arm64.h.

const int64_t kSSignMask = 0x1L << kSSignBit

Definition at line 91 of file constants-arm64.h.

Referenced by TEST().

char kStartTable[kStartTableLines *kStartTableEntriesPerLine]

Definition at line 3692 of file mark-compact.cc.

const int kStatementPositionTag = 2

Definition at line 348 of file assembler.cc.

Referenced by RelocIterator::next().

const uint32_t kStopCodeMask = kStopCode - 1

Definition at line 364 of file constants-arm.h.

const int kStringBuilderConcatHelperLengthBits = 11

Definition at line 3400 of file runtime.cc.

const int kStringBuilderConcatHelperPositionBits = 19

Definition at line 3401 of file runtime.cc.

const uint32_t kStringEncodingMask = 0x4

Definition at line 609 of file objects.h.

Referenced by HGraphBuilder::BuildCreateConsString(), HGraphBuilder::BuildUncheckedStringAdd(), String::GetExternalStringResourceBase(), StaticVisitorBase::GetVisitorId(), String::IsOneByteRepresentation(), String::IsOneByteRepresentationUnderneath(), String::IsTwoByteRepresentation(), String::IsTwoByteRepresentationUnderneath(), HeapObject::IterateBody(), and String::Visit().

const uint32_t kStringRepresentationMask = 0x03

Definition at line 615 of file objects.h.

Referenced by HGraphBuilder::BuildUncheckedStringAdd(), StaticVisitorBase::GetVisitorId(), HeapObject::IterateBody(), and String::Visit().

const uint32_t kStringTag = 0x0

Definition at line 598 of file objects.h.

Referenced by MacroAssembler::IsObjectJSStringType(), and MacroAssembler::IsObjectStringType().

const Instr kStrRegFpNegOffsetPattern

const Instr kStrRegFpOffsetPattern

const int kStubMajorKeyBits = 7

Definition at line 316 of file objects.h.

const int kStubMinorKeyBits = kBitsPerInt - kSmiTagSize - kStubMajorKeyBits

Definition at line 317 of file objects.h.

const Instr kSwRegFpNegOffsetPattern

const Instr kSwRegFpOffsetPattern

const int kTagBits = 2

Definition at line 319 of file assembler.cc.

const int kTagMask = (1 << kTagBits) - 1

Definition at line 320 of file assembler.cc.

const uint32_t kTwoByteStringTag = 0x0

Definition at line 610 of file objects.h.

Referenced by String::GetFlatContent(), String::IsOneByteRepresentationUnderneath(), String::IsTwoByteRepresentation(), String::IsTwoByteRepresentationUnderneath(), String::Visit(), and String::WriteToFlat().

const int kTypeCodeCount = LAZY_DEOPTIMIZATION + 1

Definition at line 54 of file serialize.h.

Referenced by ExternalReferenceDecoder::ExternalReferenceDecoder(), and ExternalReferenceDecoder::~ExternalReferenceDecoder().

const int kUC16Size = sizeof(uc16)

Definition at line 312 of file globals.h.

Referenced by Heap::AllocateTwoByteInternalizedString(), and LiteralBuffer::INLINE().

const uintptr_t kUintptrAllBitsSet = 0xFFFFFFFFu

Definition at line 283 of file globals.h.

Referenced by String::NonAsciiStart().

const int kUndefIndex = -1

Definition at line 115 of file frames-mips.h.

int kUninitializedRegExpNodePlaceHolder

const int kVariableLengthPCJumpTopTag = 1

Definition at line 336 of file assembler.cc.

Referenced by RelocIterator::next().

const int kVariableSizeSentinel = 0

Definition at line 314 of file objects.h.

Referenced by HeapObject::SizeFromMap(), and TEST().

const int kVeneerPoolTag = 1

Definition at line 353 of file assembler.cc.

Referenced by RelocIterator::next().

const uint32_t kVFPCConditionFlagBit = 1 << 29

Definition at line 394 of file constants-arm.h.

const uint32_t kVFPDefaultNaNModeControlBit = 1 << 25

Definition at line 390 of file constants-arm.h.

Referenced by TEST().

const uint32_t kVFPExceptionMask = 0xf

Definition at line 384 of file constants-arm.h.

const uint32_t kVFPFlushToZeroMask = 1 << 24

Definition at line 389 of file constants-arm.h.

const uint32_t kVFPInexactExceptionBit = 1 << 4

Definition at line 388 of file constants-arm.h.

const uint32_t kVFPInvalidOpExceptionBit = 1 << 0

Definition at line 385 of file constants-arm.h.

const uint32_t kVFPNConditionFlagBit = 1 << 31

Definition at line 392 of file constants-arm.h.

const uint32_t kVFPOverflowExceptionBit = 1 << 2

Definition at line 386 of file constants-arm.h.

const uint32_t kVFPRoundingModeMask = 3 << 22

Definition at line 412 of file constants-arm.h.

const uint32_t kVFPUnderflowExceptionBit = 1 << 3

Definition at line 387 of file constants-arm.h.

const uint32_t kVFPVConditionFlagBit = 1 << 28

Definition at line 395 of file constants-arm.h.

const uint32_t kVFPZConditionFlagBit = 1 << 30

Definition at line 393 of file constants-arm.h.

const Instr kVldrDPCMask

const Instr kVldrDPCPattern

const int32_t kWMaxInt = 0x7fffffff

Definition at line 107 of file constants-arm64.h.

Referenced by TEST().

const uint64_t kWMaxUInt = 0xffffffffUL

Definition at line 104 of file constants-arm64.h.

const int32_t kWMinInt = 0x80000000

Definition at line 108 of file constants-arm64.h.

Referenced by TEST().

const int64_t kWordMask = 0xffffffffL

Definition at line 102 of file constants-arm64.h.

const unsigned kWordSize = 32

Definition at line 122 of file constants-arm64.h.

const unsigned kWordSizeInBytes = kWordSize >> 3

Definition at line 124 of file constants-arm64.h.

const unsigned kWordSizeInBytesLog2 = kWordSizeLog2 - 3

Definition at line 125 of file constants-arm64.h.

const unsigned kWordSizeLog2 = 5

Definition at line 123 of file constants-arm64.h.

const int64_t kWRegMask = 0x00000000ffffffffL

Definition at line 82 of file constants-arm64.h.

const unsigned kWRegSize = kWRegSizeInBits >> 3

Definition at line 68 of file constants-arm64.h.

Referenced by RegisterDump::Dump(), and TEST().

const unsigned kWRegSizeInBits = 32

Definition at line 66 of file constants-arm64.h.

Referenced by Assembler::BitN(), Assembler::ImmR(), Assembler::ImmRotate(), Assembler::ImmS(), Assembler::ImmSetBits(), CPURegister::IsValidRegister(), Operand::Operand(), PopulateRegisterArray(), MacroAssembler::PopWRegList(), MacroAssembler::PushWRegList(), TEST(), and Register::WRegFromCode().

const unsigned kWRegSizeInBitsLog2 = 5

Definition at line 67 of file constants-arm64.h.

const unsigned kWRegSizeLog2 = kWRegSizeInBitsLog2 - 3

Definition at line 69 of file constants-arm64.h.

const int64_t kWSignBit = 31

Definition at line 94 of file constants-arm64.h.

const int64_t kWSignMask = 0x1L << kWSignBit

Definition at line 95 of file constants-arm64.h.

const int64_t kXMaxInt = 0x7fffffffffffffffL

Definition at line 105 of file constants-arm64.h.

Referenced by TEST().

const uint64_t kXMaxUInt = 0xffffffffffffffffUL

Definition at line 103 of file constants-arm64.h.

const int64_t kXMinInt = 0x8000000000000000L

Definition at line 106 of file constants-arm64.h.

Referenced by TEST().

const int64_t kXRegMask = 0xffffffffffffffffL

Definition at line 83 of file constants-arm64.h.

const unsigned kXRegSize = kXRegSizeInBits >> 3

Definition at line 72 of file constants-arm64.h.

Referenced by RegisterDump::Dump().

const unsigned kXRegSizeInBits = 64

Definition at line 70 of file constants-arm64.h.

Referenced by Assembler::BitN(), MacroAssembler::Claim(), MacroAssembler::ClaimBySMI(), Clobber(), MacroAssembler::Drop(), MacroAssembler::DropBySMI(), Register::from_code(), Assembler::ImmR(), Assembler::ImmRotate(), Assembler::ImmS(), Assembler::ImmSetBits(), CPURegister::IsValidRegister(), Operand::Operand(), PopulateRegisterArray(), MacroAssembler::PopXRegList(), MacroAssembler::PushXRegList(), TEST(), and Register::XRegFromCode().

const unsigned kXRegSizeInBitsLog2 = 6

Definition at line 71 of file constants-arm64.h.

const unsigned kXRegSizeLog2 = kXRegSizeInBitsLog2 - 3

Definition at line 73 of file constants-arm64.h.

const int64_t kXSignBit = 63

Definition at line 92 of file constants-arm64.h.

const int64_t kXSignMask = 0x1L << kXSignBit

Definition at line 93 of file constants-arm64.h.

const Address kZapValue = reinterpret_cast<Address>(0xdeadbeef)

Definition at line 82 of file v8globals.h.

Referenced by MemoryAllocator::ZapBlock().

const unsigned kZeroRegCode = 31

Definition at line 111 of file constants-arm64.h.

Referenced by CPURegister::IsZero(), Disassembler::RaIsZROrSP(), Disassembler::RdIsZROrSP(), Disassembler::RmIsZROrSP(), Disassembler::RnIsZROrSP(), and TEST().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with turns on browser compatible mode for profiling v8 log

Definition at line 806 of file flags.cc.

Referenced by PreParser::PreParseLazyFunction().

const Register lr = { kRegister_lr_Code }

Definition at line 243 of file assembler-arm.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), TEST(), and TEST_().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf map

Definition at line 350 of file flags.cc.

Referenced by HGraphBuilder::AddStoreMapConstant(), HGraphBuilder::AddStoreMapNoWriteBarrier(), Heap::AllocateInternalizedStringImpl(), Heap::AllocateJSFunctionProxy(), Heap::AllocateJSModule(), Heap::AllocateJSProxy(), Heap::AllocateMap(), Heap::AllocateOneByteInternalizedString(), Heap::AllocateStruct(), Heap::AllocateTwoByteInternalizedString(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), TypeFeedbackOracle::CanRetainOtherContext(), TypeFeedbackOracle::CollectReceiverTypes(), TypeFeedbackOracle::CompareType(), Heap::DoScavengeObject(), IC::GetCodeCacheHolder(), StoreGlobalStub::GetCodeCopyFromTemplate(), GetEnumPropertyKeys(), BASE_EMBEDDED< Visitor >::GetFieldIndex(), Internals::GetInstanceType(), BASE_EMBEDDED< Visitor >::GetValue(), V8_FINAL< kOperandKind, kNumCachedOperands >::HasMap(), StaticNewSpaceVisitor< NewSpaceScavenger >::INLINE(), StaticMarkingVisitor< MarkCompactMarkingVisitor >::INLINE(), Accessors::IsJSObjectFieldAccessor(), Object::IsStruct(), V8_FINAL< kOperandKind, kNumCachedOperands >::LCheckMapValue(), V8_FINAL< kOperandKind, kNumCachedOperands >::LForInCacheArray(), Interface::Lookup(), Object::Lookup(), StubCache::map_reference(), Factory::NewGlobalObject(), Factory::NewJSGeneratorObject(), Factory::NewRawConsString(), Factory::NewRawSlicedString(), Factory::ObjectLiteralMapFromCache(), MarkCompactMarkingVisitor::ObjectStatsVisitBase(), StringStream::PrintFunction(), StringStream::PrintSecurityTokenIfChanged(), StringStream::PrintUsingMap(), Heap::ReinitializeJSReceiver(), RUNTIME_FUNCTION(), ICCompareStub::set_known_map(), JSObjectWalkVisitor< ContextObject >::StructureWalk(), TEST(), ArrayConcatVisitor::ToArray(), HOptimizedGraphBuilder::ToType(), IC::TryRemoveInvalidPrototypeDependentStub(), IC::TypeToMap(), KeyedLookupCache::Update(), CompareIC::UpdateCaches(), IC::UpdateMegamorphicCache(), IC::UpdateState(), and FastElementsAccessor< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS >, kPointerSize >::ValidateContents().

const unsigned int MAX_FIRST_ARG = 0x7fffffu

Definition at line 40 of file bytecodes-irregexp.h.

const int MB = KB * KB

Definition at line 246 of file globals.h.

Referenced by MarkCompactCollector::CollectEvacuationCandidates(), Heap::ConfigureHeap(), Heap::ConfigureHeapDefault(), IncrementalMarking::Step(), TEST(), and IncrementalMarking::WorthActivating().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage message

Definition at line 665 of file flags.cc.

Referenced by Heap::AllocateJSMessageObject(), MessageHandler::GetMessage(), MessageHandler::MakeMessageObject(), Isolate::RestorePendingMessageFromTryCatch(), and RUNTIME_FUNCTION().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in name

Definition at line 505 of file flags.cc.

Referenced by HGraphBuilder::Add(), HGraphBuilder::AddUncasted(), CodeStubGraphBuilderBase::BuildGraph(), Scope::CheckConflictingVarDeclarations(), FixedArrayAppender::Contains(), IC::CopyICToMegamorphicCache(), ScopeInfo::Create(), OptimizedCompileJob::CreateGraph(), SharedFunctionInfo::DebugName(), Runtime::DeleteObjectProperty(), Scope::DeserializeScopeChain(), JSObject::EnqueueChangeRecord(), JSObject::ExpectedTransitionKey(), JSProxy::GetElementWithHandler(), JSObject::GetPropertyWithCallback(), JSProxy::GetPropertyWithHandler(), Scope::HasArgumentsParameter(), Object::HasSpecificClassOf(), Instrument::Instrument(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsVariable(), LowLevelLogger::LowLevelLogger(), Factory::NewGlobalObject(), ParserBase< Traits >::ParseIdentifier(), ParserBase< Traits >::ParseLeftHandSideExpression(), ParserBase< Traits >::ParseMemberExpression(), ParserBase< Traits >::ParseMemberExpressionContinuation(), ParserBase< Traits >::ParseObjectLiteral(), ParserBase< Traits >::ParsePrimaryExpression(), StringStream::PrintPrototype(), Heap::ReinitializeJSReceiver(), NewSpace::ReportStatistics(), ParserBase< Traits >::ReportUnexpectedToken(), RUNTIME_FUNCTION(), TransitionArray::Search(), Search(), BASE_EMBEDDED< Visitor >::set_name(), JSObject::SetAccessor(), JSObject::SetPropertyForResult(), JSProxy::SetPropertyViaPrototypesWithHandler(), JSObject::SetPropertyWithCallback(), SharedFunctionInfo::SourceCodePrint(), TEST(), KeyedLookupCache::Update(), DescriptorLookupCache::Update(), V8_FINAL< kOperandKind, kNumCachedOperands >::WithRepresentation(), HPhase::~HPhase(), LAllocatorPhase::~LAllocatorPhase(), and LPhase::~LPhase().

name_should_print_as_anonymous

Definition at line 5283 of file objects-inl.h.

kInstanceClassNameOffset needs_access_check

Definition at line 5115 of file objects-inl.h.

const CRegister no_creg = { -1 }

Definition at line 508 of file assembler-arm.h.

const IntelDoubleRegister no_double_reg = { -1 }

Definition at line 186 of file assembler-ia32.h.

const DwVfpRegister no_dreg = { -1 }

Definition at line 429 of file assembler-arm.h.

const FPUControlRegister no_fpucreg = { kInvalidFPUControlRegister }

Definition at line 343 of file assembler-mips.h.

const FPURegister no_freg = { -1 }

Definition at line 275 of file assembler-mips.h.

const Register no_reg = { kRegister_no_reg_Code }

Definition at line 223 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), LoadStubCompiler::GenerateLoadViaGetterForDeopt(), StoreStubCompiler::GenerateStoreViaSetterForDeopt(), BASE_EMBEDDED< Visitor >::is_reg(), BASE_EMBEDDED< Visitor >::offset(), and BASE_EMBEDDED< Visitor >::set_offset().

const Instr nopInstr = 0

Definition at line 613 of file constants-mips.h.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension NULL

Definition at line 269 of file flags.cc.

Referenced by IncrementalMarking::Abort(), AccumulateStatsWithOperator(), GlobalHandles::Node::Acquire(), BufferedZoneList< v8::internal::RegExpTree, 2 >::Add(), HGraphBuilder::Add(), Trace::add_action(), DeferredFeedbackSlotProcessor::add_slot_node(), SamplerThread::AddActiveSampler(), V8_FINAL< kOperandKind, kNumCachedOperands >::AddArgument(), V8::AddCallCompletedCallback(), CodeFlusher::AddCandidate(), RegExpBuilder::AddCharacter(), LoopChoiceNode::AddContinueAlternative(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::AddElementsToFixedArray(), Heap::AddGCEpilogueCallback(), Heap::AddGCPrologueCallback(), GuardedAlternative::AddGuard(), HGraphBuilder::AddLoadJSBuiltin(), HGraphBuilder::AddLoadStringInstanceType(), HGraphBuilder::AddLoadStringLength(), LoopChoiceNode::AddLoopAlternative(), MemoryAllocator::AddMemoryAllocationCallback(), GlobalHandles::AddObjectGroup(), ProfileTree::AddPathFromEnd(), ProfileTree::AddPathFromStart(), RegExpBuilder::AddQuantifierToAtom(), SlotsBuffer::AddTo(), LiveRange::AddUseInterval(), LiveRange::AddUsePosition(), BASE_EMBEDDED< Visitor >::Advance(), StackFrameIterator::Advance(), SafeStackFrameIterator::Advance(), PagedSpace::AdvanceSweeper(), OptimizingCompilerThread::AgeBufferedOsrJobs(), AlignedAlloc(), OS::Allocate(), Heap::Allocate(), FreeList::Allocate(), MemoryAllocator::AllocateAlignedMemory(), Bootstrapper::AllocateAutoDeletedArray(), MemoryAllocator::AllocateChunk(), Heap::AllocateJSArrayAndStorage(), Heap::AllocateJSArrayStorage(), MemoryAllocator::AllocateLargePage(), PagedSpace::AllocateLinearly(), Scope::AllocateModulesRecursively(), Scope::AllocateNonParameterLocals(), MemoryAllocator::AllocatePage(), Scope::AllocateParameterLocals(), PagedSpace::AllocateRaw(), LargeObjectSpace::AllocateRaw(), CodeRange::AllocateRawMemory(), Scope::AllocateVariables(), AllocationSpaceName(), Scope::Analyze(), HFlowEngine< State, Effects >::AnalyzeDominatedBlocks(), AppendChars(), CodeEventLogger::NameBuffer::AppendString(), BASE_EMBEDDED< Visitor >::Apply(), MarkCompactCollector::AreSweeperThreadsActivated(), V8_FINAL< kOperandKind, kNumCachedOperands >::arguments_pushed(), AstNode::AsBreakableStatement(), AstNode::AsIterationStatement(), AstNode::AsMaterializedLiteral(), CodeCacheHashTableKey::AsObject(), RegExpKey::AsObject(), InternalizedStringKey::AsObject(), TwoCharHashTableKey::AsObject(), RegExpCompiler::Assemble(), AssemblerBase::AssemblerBase(), V8_FINAL< kOperandKind, kNumCachedOperands >::AsSimpleAssignment(), AstNode::AsTargetCollector(), TypeFeedbackOracle::BinaryType(), BreakableStatement::BreakableStatement(), HGraphBuilder::BuildArrayBufferViewInitialization(), CodeStubGraphBuilderBase::BuildArrayConstructor(), HGraphBuilder::BuildBinaryOperation(), CodeStubGraphBuilderBase::BuildCheckAndInstallOptimizedCode(), CodeStubGraphBuilder< Stub >::BuildCodeInitializedStub(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), CodeStubGraphBuilderBase::BuildGraph(), HOptimizedGraphBuilder::BuildGraph(), CodeStubGraphBuilderBase::BuildInstallCode(), CodeStubGraphBuilderBase::BuildInstallFromOptimizedCodeMap(), CodeStubGraphBuilderBase::BuildInternalArrayConstructor(), CodeStubGraphBuilderBase::BuildLoadNamedField(), ScriptDataImpl::BuildMessage(), HOsrBuilder::BuildOsrLoopEntry(), ParserTraits::BuildUnaryExpression(), BUILTIN(), CharacterRangeSplitter::Call(), StoreBufferRebuilder::Callback(), CpuProfiler::CallbackEvent(), CallOnce(), LiveRange::CanBeSpilled(), V8_FINAL< kOperandKind, kNumCachedOperands >::Canonicalize(), TypeFeedbackOracle::CanRetainOtherContext(), BASE_EMBEDDED< Visitor >::captures_started(), SlotsBuffer::ChainLengthThresholdReached(), CharacterRange::CharacterRange(), CheckArrayAbuse(), ParserTraits::CheckAssigningFunctionLiteralToProperty(), Scope::CheckConflictingVarDeclarations(), ParserTraits::CheckFunctionLiteralInsideTopLevelObjectLiteral(), BASE_EMBEDDED< Visitor >::CheckHoistability(), ParserTraits::CheckPossibleEvalCall(), ParserTraits::CheckStrictModeLValue(), TraversableMap::ChildIteratorNext(), ContextSlotCache::Clear(), TemplateHashMapImpl< AllocationPolicy >::Clear(), BufferedZoneList< v8::internal::RegExpTree, 2 >::Clear(), BASE_EMBEDDED< Visitor >::Clear(), CompareNilIC::Clear(), KeyedLookupCache::Clear(), DescriptorLookupCache::Clear(), HValue::clear_block(), Segment::clear_next(), Heap::ClearAllICsByKind(), V8_FINAL< kOperandKind, kNumCachedOperands >::ClearEnvironment(), MemoryChunk::ClearEvacuationCandidate(), Code::ClearInlineCaches(), V8_FINAL< kOperandKind, kNumCachedOperands >::ClearInlinedTestContext(), MarkCompactCollector::ClearMarkbits(), StringStream::ClearMentionedObjectCache(), Ticker::ClearProfiler(), OS::ClearTimezoneCache(), GlobalHandles::Node::ClearWeakness(), Log::Close(), V8_FINAL< kOperandKind, kNumCachedOperands >::CloseFile(), CpuProfiler::CodeCreateEvent(), CodeEventLogger::CodeCreateEvent(), LChunk::Codegen(), CodeGenerationFromStringsAllowed(), Logger::CodeNameEvent(), Logger::CodeStartLinePosInfoRecordEvent(), V8_FINAL< kOperandKind, kNumCachedOperands >::CodeTracer(), Heap::CollectAllAvailableGarbage(), MarkCompactCollector::CollectEvacuationCandidates(), MarkCompactCollector::CollectGarbage(), Heap::CollectGarbage(), BASE_EMBEDDED< Visitor >::CollectInductionVariableData(), TypeFeedbackOracle::CollectReceiverTypes(), Scope::CollectStackAndContextLocals(), NewSpace::CollectStatistics(), CompilationInfo::CommitDependencies(), VirtualMemory::CommitRegion(), LargeObjectSpace::CommittedPhysicalMemory(), TypeFeedbackOracle::CompareType(), RegExpEngine::Compile(), Compiler::CompileScript(), FreeListCategory::Concatenate(), Isolate::concurrent_osr_enabled(), Isolate::concurrent_recompilation_enabled(), NestedEffectsBase< int, kNoVar >::Contains(), HeapObjectsSet::Contains(), CodeRange::contains(), FreeListCategory::ContainsPageFreeListItemsInList(), Scope::ContextChainLength(), Scope::ContextLocalCount(), ScopeInfo::ContextSlotIndex(), ConsStringIteratorOp::ContinueOperation(), HFieldApproximation::Copy(), GlobalHandles::CopyGlobal(), Heap::CopyJSObject(), Counter::Counter(), Isolate::counters(), LiveRange::Covers(), BoundsCheckKey::Create(), GlobalHandles::Create(), OS::MemoryMappedFile::create(), EternalHandles::Create(), ScopeInfo::Create(), BASE_EMBEDDED< Visitor >::CreateAllocationMementos(), LiveRange::CreateAssignedOperand(), PostorderProcessor::CreateEntryProcessor(), OptimizedCompileJob::CreateGraph(), StatsTable::CreateHistogram(), HOptimizedGraphBuilder::CreateJoin(), HOptimizedGraphBuilder::CreateLoop(), Thread::CreateThreadLocalKey(), OS::CreateTimezoneCache(), V8_FINAL< kOperandKind, kNumCachedOperands >::CreateUninitialized(), BASE_EMBEDDED< Visitor >::Current(), V8_FINAL< kOperandKind, kNumCachedOperands >::current_loop(), BASE_EMBEDDED< Visitor >::Element::CurrentDominatedBlock(), Map::CurrentMapForDeprecatedInternal(), DummyResource::data(), DummyOneByteResource::data(), OS::DaylightSavingsOffset(), SlotsBufferAllocator::DeallocateChain(), VariableMap::Declare(), ExternalReferenceDecoder::Decode(), GlobalHandles::NodeBlock::DecreaseUses(), MessageHandler::DefaultMessageReport(), JSObject::DefineAccessor(), HeapProfiler::DefineWrapperClass(), Zone::DeleteAll(), HValue::DeleteAndReplaceWith(), DictionaryElementsAccessor::DeleteCommon(), HandleScopeImplementer::DeleteExtensions(), Zone::DeleteKeptSegment(), CompilationInfo::dependencies(), BASE_EMBEDDED< Visitor >::DescriptorResult(), Deserializer::Deserialize(), Deserializer::DeserializePartial(), Scope::DeserializeScopeChain(), GlobalHandles::Destroy(), PromotionQueue::Destroy(), SmartPointerBase< ObjectDeallocator< v8::internal::HeapObjectsMap >, v8::internal::HeapObjectsMap >::Detach(), BASE_EMBEDDED< Visitor >::DetachJITHandlerData(), V8_FINAL< kOperandKind, kNumCachedOperands >::DetectCompoundIndex(), V8_FINAL< kOperandKind, kNumCachedOperands >::DetectInductionVariable(), BASE_EMBEDDED< Visitor >::DictionaryResult(), Serializer::Disable(), Heap::DisableInlineAllocation(), Vector< const uint8_t >::Dispose(), SourceResource::Dispose(), OS::DisposeTimezoneCache(), LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), LCodeGen::DoGap(), BASE_EMBEDDED< Visitor >::done(), Interface::Iterator::done(), GlobalHandles::NodeIterator::done(), BASE_EMBEDDED< Visitor >::Done(), Isolate::DoThrow(), DoubleToPrecisionCString(), DumpBacktrace(), ChoiceNode::EatsAtLeast(), BASE_EMBEDDED< Visitor >::Eliminate(), V8_FINAL< kOperandKind, kNumCachedOperands >::Eliminate(), BASE_EMBEDDED< Visitor >::EliminateRedundantBoundsChecks(), ActionNode::Emit(), ChoiceNode::Emit(), LoopChoiceNode::Emit(), Vector< const uint8_t >::empty(), PagedSpace::EmptyAllocationInfo(), ParserTraits::EmptyExpression(), ParserTraits::EmptyLiteral(), MarkCompactCollector::EnableCodeFlushing(), StatsCounter::Enabled(), Histogram::Enabled(), ExternalReferenceEncoder::Encode(), TemplateHashMap< Literal, ObjectLiteral::Accessors, ZoneAllocationPolicy >::end(), RegExpStack::EnsureCapacity(), Deoptimizer::EnsureCodeForDeoptimizationEntry(), Isolate::EnsureDefaultIsolate(), LiveRange::EnsureInterval(), StoreBuffer::EnsureSpace(), Isolate::EnterDefaultIsolate(), StoreBuffer::EnterDirectlyIntoStoreBuffer(), Analysis::error_message(), V8HeapExplorer::EstimateObjectsCount(), CodeFlusher::EvictCandidate(), PagedSpace::EvictEvacuationCandidatesFromFreeLists(), FreeListCategory::EvictFreeListItemsInList(), CodeFlusher::EvictOptimizedCodeMap(), HeapProfiler::ExecuteWrapperClassCallback(), CodeRange::exists(), LDeferredCode::exit(), PagedSpace::Expand(), ParserTraits::ExpressionFromIdentifier(), ParserTraits::ExpressionFromLiteral(), ParserTraits::ExpressionFromString(), OutSet::Extend(), LControlInstruction< 0, 1 >::FalseLabel(), FileByteSink::FileByteSink(), ChoiceNode::FillInBMInfo(), StoreBuffer::Filter(), TextNode::FilterASCII(), ChoiceNode::FilterASCII(), NegativeLookaheadChoiceNode::FilterASCII(), LoopChoiceNode::FilterASCII(), SeqRegExpNode::FilterSuccessor(), Scope::FinalizeBlockScope(), Heap::FinalizeExternalString(), NestedEffectsBase< int, kNoVar >::Find(), FrameFunctionIterator::Find(), Map::FindAccessor(), FindAsciiStringIndices(), AllocationTraceNode::FindChild(), ProfileNode::FindChild(), HeapObjectsMap::FindEntry(), CodeMap::FindEntry(), SnapshotFiller::FindEntry(), Code::FindFirstAllocationSite(), Code::FindFirstHandler(), Code::FindFirstMap(), Code::FindFirstName(), SplayTree< Config, AllocationPolicy >::FindGreatest(), HeapProfiler::FindHeapObjectById(), SplayTree< Config, AllocationPolicy >::FindLeast(), StatsTable::FindLocation(), Code::FindNthObject(), PagedSpace::FindObject(), LargeObjectSpace::FindObject(), AllocationTraceNode::FindOrAddChild(), ProfileNode::FindOrAddChild(), HeapObjectsMap::FindOrAddEntry(), SnapshotFiller::FindOrAddEntry(), LargeObjectSpace::FindPage(), Isolate::FindPerThreadDataForThread(), OptimizingCompilerThread::FindReadyOSRCandidate(), HeapObjectsMap::FindUntrackedObjects(), Map::FindUpdatedMap(), HCheckTable::Finish(), HLoadEliminationTable::Finish(), V8::FireCallCompletedCallback(), StubCache::first_entry(), LiveRange::FirstHint(), LiveRange::FirstIntersection(), HControlInstruction::FirstSuccessor(), Trace::Flush(), OS::FOpen(), BASE_EMBEDDED< Visitor >::Free(), MemoryAllocator::Free(), FreeListCategory::Free(), Runtime::FreeArrayBuffer(), Heap::FreeQueuedChunks(), LargeObjectSpace::FreeUnmarkedObjects(), MemoryChunk::FromAnyPointerAddress(), ScopeInfo::FunctionContextSlotIndex(), V8_FINAL< kOperandKind, kNumCachedOperands >::FunctionDeclaration(), Runtime::FunctionForName(), Accessors::FunctionGetArguments(), Accessors::FunctionGetPrototype(), Accessors::FunctionSetPrototype(), InnerPointerToCodeCache::GcSafeCastToCode(), InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), Map::GeneralizeRepresentation(), ICCompareStub::Generate(), PlatformCodeStub::GenerateCode(), OptimizedCompileJob::GenerateCode(), HydrogenCodeStub::GenerateLightweightMissCode(), BufferedZoneList< v8::internal::RegExpTree, 2 >::Get(), OutSet::Get(), SetOncePointer< HConstant >::get(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::Get(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::GetAccessorPair(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::GetAccessorPairImpl(), DictionaryElementsAccessor::GetAccessorPairImpl(), SloppyArgumentsElementsAccessor::GetAccessorPairImpl(), CodeStubGraphBuilderBase::GetArgumentsLength(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::GetAttributes(), MaterializedLiteral::GetBoilerplateValue(), SharedFunctionInfo::GetCodeFromOptimizedCodeMap(), V8HeapExplorer::GetConstructorName(), StringsStorage::GetCopy(), DateCacheMock::GetDaylightSavingsOffsetFromOS(), OptimizedFrame::GetDeoptimizationData(), Deoptimizer::GetDeoptimizationEntry(), Deoptimizer::GetDeoptimizationId(), HeapSnapshot::GetEntryById(), HeapObject::GetHeap(), StatsCounter::GetInternalPointer(), TraceExtension::GetJsEntrySp(), BASE_EMBEDDED< Visitor >::GetLazyValue(), BufferedZoneList< v8::internal::RegExpTree, 2 >::GetList(), SharedFunctionInfo::GetLiteralsFromOptimizedCodeMap(), JSObject::GetLocalElementAccessorPair(), JSObject::GetLocalElementKeys(), JSObject::GetLocalPropertyAccessorPair(), TaskQueue::GetNext(), StringCharacterStream::GetNext(), LGap::GetOrCreateParallelMove(), Object::GetProperty(), JSObject::GetPropertyWithCallback(), Object::GetPropertyWithDefinedGetter(), OS::GetRandomMmapAddr(), Code::GetRawAge(), Expression::GetReceiverTypes(), V8_FINAL< kOperandKind, kNumCachedOperands >::GetReceiverTypes(), GetScriptNameOrSourceURL(), GetScriptWrapper(), Version::GetSONAME(), HandleScopeImplementer::GetSpareOrNewBlock(), ExitFrame::GetStateForFramePointer(), CompareIC::GetStateName(), Trace::GetStoredPosition(), RegExpNode::GetSuccessorOfOmnivorousTextNode(), TextNode::GetSuccessorOfOmnivorousTextNode(), ChoiceNode::GetTable(), HeapObjectsSet::GetTag(), CpuProfiler::GetterCallbackEvent(), String::GetTwoByteData(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::GetType(), StringsStorage::GetUsedMemorySize(), CompileTimeValue::GetValue(), CompilationInfo::global_object(), V8_FINAL< kOperandKind, kNumCachedOperands >::GotoNoSimulate(), HGraphBuilder::GotoNoSimulate(), Deoptimizer::Grab(), HeapStringAllocator::grow(), NativeRegExpMacroAssembler::GrowStack(), VirtualMemory::Guard(), Handle< v8::internal::JSFunction >::Handle(), BASE_EMBEDDED< Visitor >::HandlerResult(), Context::has_extension(), Analysis::has_failed(), CompilationInfo::has_global_object(), V8_FINAL< kOperandKind, kNumCachedOperands >::has_osr(), V8_FINAL< kOperandKind, kNumCachedOperands >::has_uint32_instructions(), LiveRange::HasAllocatedSpillOperand(), Heap::HasBeenSetUp(), SemiSpace::HasBeenSetUp(), StatsTable::HasCounterFunction(), ElementsAccessorBase< FastPackedSmiElementsAccessor, ElementsKindTraits< FAST_SMI_ELEMENTS > >::HasElement(), V8_FINAL< kOperandKind, kNumCachedOperands >::HasEnvironment(), LInstruction::HasEnvironment(), JSObject::HasExternalArrayElements(), JSObject::HasFixedTypedArrayElements(), IteratingStringHasher::Hash(), UsePosition::HasHint(), Scope::HasIllegalRedeclaration(), Scope::HasLazyCompilableOuterContext(), StringCharacterStream::HasMore(), HValue::HasMultipleUses(), HValue::HasNoUses(), UsePosition::HasOperand(), V8_FINAL< kOperandKind, kNumCachedOperands >::HasParentLoopHeader(), HValue::HasRange(), V8_FINAL< kOperandKind, kNumCachedOperands >::HasReplacement(), LTemplateResultInstruction< 1 >::HasResult(), InlineSmiCheckInfo::HasSmiCheck(), Thread::HasThreadLocal(), Scope::HasTrivialContext(), Scope::HasTrivialOuterContext(), Script::HasValidSource(), HBinaryOperation::HBinaryOperation(), V8_FINAL< kOperandKind, kNumCachedOperands >::HCapturedObject(), HeapObjectIterator::HeapObjectIterator(), HeapObjectsMap::HeapObjectsMap(), HEnvironmentLivenessAnalysisPhase::HEnvironmentLivenessAnalysisPhase(), HFlowEngine< State, Effects >::HFlowEngine(), BASE_EMBEDDED< Visitor >::HInstructionIterator(), V8_FINAL< kOperandKind, kNumCachedOperands >::HTracer(), IC::IC(), GlobalHandles::NodeBlock::IncreaseUses(), BASE_EMBEDDED< Visitor >::Initialize(), V8::Initialize(), Scope::Initialize(), HandleScopeData::Initialize(), PromotionQueue::Initialize(), MemoryChunk::Initialize(), BreakIterator::InitializeBreakIterator(), Collator::InitializeCollator(), DateFormat::InitializeDateTimeFormat(), InitializeICU(), TimezoneCache::InitializeIfNeeded(), Runtime::InitializeIntrinsicFunctionNames(), BASE_EMBEDDED< Visitor >::Element::InitializeLoop(), NumberFormat::InitializeNumberFormat(), SlotsBuffer::INLINE(), Isolate::INLINE(), Assembler::INLINE(), AllocationInfo::INLINE(), IntSet::Insert(), NestedEffectsBase< Var, kNoVar >::Insert(), PromotionQueue::insert(), HInstruction::InsertAfter(), HInstruction::InsertBefore(), ExternalReferenceTable::instance(), Execution::InstantiateObject(), Instrument::Instrument(), BASE_EMBEDDED< Visitor >::InterceptorResult(), Heap::InternalizedStringMapForString(), Heap::InternalizeString(), Heap::InternalizeStringWithKey(), StackGuard::InvokeInterruptCallback(), RegExpImpl::IrregexpExec(), MarkCompactCollector::is_code_flushing_enabled(), V8_FINAL< kOperandKind, kNumCachedOperands >::is_default(), SmartPointerBase< ObjectDeallocator< v8::internal::HeapObjectsMap >, v8::internal::HeapObjectsMap >::is_empty(), SplayTree< v8::internal::DispatchTable::Config, ZoneAllocationPolicy >::is_empty(), NestedEffectsBase< int, kNoVar >::is_empty(), PromotionQueue::is_empty(), V8_FINAL< kOperandKind, kNumCachedOperands >::is_fast_smi_loop(), V8_FINAL< kOperandKind, kNumCachedOperands >::is_jsruntime(), Logger::is_logging_code_events(), Handle< v8::internal::JSFunction >::is_null(), SetOncePointer< HConstant >::is_set(), Trace::is_trivial(), BASE_EMBEDDED< Visitor >::is_valid(), MemoryChunk::is_valid(), PerThreadAssertScope< type, allow >::IsAllowed(), ThreadManager::IsArchived(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsArguments(), LiveRange::IsChild(), CompileTimeValue::IsCompileTimeValue(), Scope::IsDeclared(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsDeoptimizing(), SourceResource::IsDisposed(), BASE_EMBEDDED< Visitor >::IsEliminated(), Statement::IsEmpty(), NestedEffectsBase< int, kNoVar >::IsEmpty(), LiveRange::IsEmpty(), LargeObjectSpace::IsEmpty(), Log::IsEnabled(), Isolate::IsExternallyCaught(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsFalseReachable(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsFinished(), Variable::IsGlobalObjectProperty(), ParserTraits::IsIdentifier(), BASE_EMBEDDED< Visitor >::IsIgnored(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsInductionVariable(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsInitialized(), MacroAssembler::IsInstanceJSObjectType(), Isolate::IsInUse(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsJump(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsLimitedInductionVariable(), HInstruction::IsLinked(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsLoopHeader(), SerializationAddressMapper::IsMapped(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsNestedInThisLoop(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsNull(), Expression::IsNullLiteral(), MacroAssembler::IsObjectJSStringType(), HValue::isolate(), BASE_EMBEDDED< Visitor >::IsPending(), OptimizingCompilerThread::IsQueuedForOSR(), LGap::IsRedundant(), VirtualMemory::IsReserved(), Expression::IsSmiLiteral(), Expression::IsStringLiteral(), ParserTraits::IsThisProperty(), IC::IsTransitionOfMonomorphicTarget(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsTrueReachable(), Expression::IsUndefinedLiteral(), V8_FINAL< kOperandKind, kNumCachedOperands >::IsValidLeftHandSide(), ThreadManager::Iterate(), Isolate::Iterate(), V8HeapExplorer::IterateAndExtractReferences(), NativeObjectsExplorer::IterateAndExtractReferences(), ThreadManager::IterateArchivedThreads(), Isolate::IterateDeferredHandles(), GlobalHandles::IterateObjectGroups(), CodeFlusher::IteratePointersToFromSpace(), Heap::IterateStrongRoots(), Thread::Join(), HOptimizedGraphBuilder::JoinContinue(), MacroAssembler::JumpIfBothNotSmi(), MacroAssembler::JumpIfEitherNotSmi(), HValue::Kill(), Code::Kind2String(), HControlInstruction::KnownSuccessorBlock(), V8_FINAL< kOperandKind, kNumCachedOperands >::KnownSuccessorBlock(), HCompareObjectEqAndBranch::KnownSuccessorBlock(), LargeObjectIterator::LargeObjectIterator(), BufferedZoneList< v8::internal::RegExpTree, 2 >::last(), lazily_initialize_fast_exp(), BufferedZoneList< v8::internal::RegExpTree, 2 >::length(), LGap::LGap(), RegExpNode::LimitVersions(), KeyedLoadIC::Load(), CodeStubGraphBuilderBase::LoadFromOptimizedCodeMap(), Variable::local_if_not_shadowed(), Scope::LocalLookup(), OS::LocalTimeOffset(), OS::LocalTimezone(), Logger::LogAccessorCallbacks(), Logger::LogCodeObjects(), Logger::LogCompiledFunctions(), Logger::LogExistingFunction(), Isolate::logger(), CompleteParserRecorder::LogMessage(), OS::LogSharedLibraryAddresses(), ContextSlotCache::Lookup(), VariableMap::Lookup(), TemplateHashMapImpl< AllocationPolicy >::Lookup(), CompilationCacheScript::Lookup(), Scope::Lookup(), CompilationCacheEval::Lookup(), Interface::Lookup(), CompilationCacheRegExp::Lookup(), V8_FINAL< kOperandKind, kNumCachedOperands >::Lookup(), AccessorTable::lookup(), Object::Lookup(), LChunk::LookupDestination(), Map::LookupElementsTransitionMap(), Scope::LookupFunctionVar(), Scope::LookupRecursive(), V8_FINAL< kOperandKind, kNumCachedOperands >::LookupValue(), V8_FINAL< kOperandKind, kNumCachedOperands >::LowerLimitIsNonNegativeConstant(), LowLevelLogger::LowLevelLogger(), FullCodeGenerator::MakeCode(), Code::MakeOlder(), GlobalHandles::Node::MakeWeak(), HeapEntriesMap::Map(), MemoryChunk::MarkEvacuationCandidate(), ParserTraits::MarkExpressionAsLValue(), V8_FINAL< kOperandKind, kNumCachedOperands >::materialization_marker(), Deoptimizer::MaterializeHeapObjects(), MemsetPointer(), Trace::mentions_reg(), HCheckTable::Merge(), HLoadEliminationTable::Merge(), Deoptimizer::MessageFor(), Representation::Mnemonic(), Variable::Mode2String(), HeapObjectsMap::MoveObject(), ExternalReferenceEncoder::NameOfAddress(), NativesExternalStringResource::NativesExternalStringResource(), JSArrayBuffer::Neuter(), ZeroingAllocationPolicy::New(), Malloced::New(), Deoptimizer::New(), NewArray(), LChunk::NewChunk(), BASE_EMBEDDED< Visitor >::NewForEachStatement(), Factory::NewFunctionFromSharedFunctionInfo(), Factory::NewJSObjectFromMap(), ThreadState::Next(), TemplateHashMapImpl< AllocationPolicy >::Next(), RelocIterator::next(), FrameFunctionIterator::next(), HeapObjectIterator::Next(), FreeListNode::next(), SemiSpaceIterator::Next(), SpaceIterator::next(), LargeObjectIterator::Next(), BASE_EMBEDDED< Visitor >::next(), IntrusiveMapTransitionIterator::Next(), IntrusivePrototypeTransitionIterator::Next(), LiveRange::NextRegisterPosition(), LiveRange::NextUsePosition(), LiveRange::NextUsePositionRegisterIsBeneficial(), Scope::NonLocal(), BASE_EMBEDDED< Visitor >::NotFound(), ParserTraits::NullExpressionList(), JSObject::NumberOfLocalElements(), IntSet::occupancy(), OS::MemoryMappedFile::open(), V8_FINAL< kOperandKind, kNumCachedOperands >::OpenFile(), ConsStringCaptureOp::Operate(), ConsStringNullOp::Operate(), SmartPointerBase< ObjectDeallocator< v8::internal::HeapObjectsMap >, v8::internal::HeapObjectsMap >::operator=(), OptimizedCompileJob::OptimizeGraph(), OptimizingCompilerThread::OptimizingCompilerThread(), Isolate::OptionalRescheduleException(), LInstruction::Output(), MemoryChunk::owner(), Heap::paged_space(), PagedSpace::PagedSpace(), HeapEntriesMap::Pair(), V8_FINAL< kOperandKind, kNumCachedOperands >::parent_loop(), Parser::Parse(), ParserBase< Traits >::ParseAssignmentExpression(), ParserBase< Traits >::ParseLeftHandSideExpression(), ParserBase< Traits >::ParseMemberExpressionContinuation(), ParserBase< Traits >::ParseObjectLiteral(), ParserBase< Traits >::ParsePrimaryExpression(), RecordWriteStub::Patch(), SamplingCircularQueue< T, Length >::Peek(), PerfBasicLogger::PerfBasicLogger(), PerfJitLogger::PerfJitLogger(), PostorderProcessor::PerformStep(), PerThreadAssertScopeBase::PerThreadAssertScopeBase(), FreeListCategory::PickNodeFromList(), BASE_EMBEDDED< Visitor >::PositionsRecorder(), FlatStringReader::PostGarbageCollection(), GlobalHandles::Node::PostGarbageCollectionProcessing(), OS::PostSetUp(), MarkCompactCollector::Prepare(), CompilationInfo::PrepareForCompilation(), StoreBuffer::PrepareForIteration(), PagedSpace::PrepareForMarkCompact(), JSObject::PrepareSlowElementsForSort(), PreParserApi::PreParse(), PreParser::PreParseProgram(), IntSet::Present(), LiveRange::PreviousUsePositionRegisterIsBeneficial(), PrintExtension::Print(), AllocationTraceNode::Print(), ProfileNode::Print(), JavaScriptFrame::Print(), LInstruction::PrintDataTo(), LGap::PrintDataTo(), LStoreKeyed< 1 >::PrintDataTo(), Code::PrintDeoptLocation(), HValue::PrintRangeTo(), Isolate::PrintStack(), LOperand::PrintTo(), HLoadEliminationTable::Process(), DeferredFeedbackSlotProcessor::ProcessFeedbackSlots(), BASE_EMBEDDED< Visitor >::ProcessRelatedChecks(), V8_FINAL< kOperandKind, kNumCachedOperands >::Push(), BufferedUtf16CharacterStream::PushBack(), FileByteSink::Put(), Isolate::random_number_generator(), BufferedUtf16CharacterStream::ReadBlock(), ReadCharsFromFile(), ReadLine(), MarkCompactCollector::RecordRelocSlot(), Heap::RecordStats(), ProfileGenerator::RecordTickSample(), V8_FINAL< kOperandKind, kNumCachedOperands >::RecordUint32Instruction(), IncrementalMarking::RecordWriteOfCodeEntrySlow(), IncrementalMarking::RecordWriteSlow(), HValue::RedefinedOperand(), CodeEventLogger::RegExpCodeCreateEvent(), RegExpNode::RegExpNode(), HValue::RegisterUse(), Heap::ReinitializeJSReceiver(), GlobalHandles::Node::Release(), CompilationInfo::ReleaseNoFrameRanges(), PagedSpace::ReleasePage(), RelocIterator::RelocIterator(), TemplateHashMapImpl< AllocationPolicy >::Remove(), SamplerThread::RemoveActiveSampler(), V8::RemoveCallCompletedCallback(), HeapObjectsMap::RemoveDeadEntries(), Heap::RemoveGCEpilogueCallback(), Heap::RemoveGCPrologueCallback(), BufferedZoneList< v8::internal::RegExpTree, 2 >::RemoveLast(), HValue::RemoveLastAddedRange(), MemoryAllocator::RemoveMemoryAllocationCallback(), Context::RemoveOptimizedFunction(), HValue::RemoveUse(), FreeListCategory::RepairFreeList(), Heap::RepairFreeListsAfterBoot(), HValue::ReplaceAllUsesWith(), SharedFunctionInfo::ReplaceCode(), PreParserTraits::ReportMessageAt(), Isolate::ReportPendingMessages(), ParserBase< Traits >::ReportUnexpectedToken(), SmallPointerList< v8::internal::Map * >::Reserve(), MemoryAllocator::ReserveAlignedMemory(), BASE_EMBEDDED< Visitor >::Reset(), SmartPointerBase< ObjectDeallocator< v8::internal::HeapObjectsMap >, v8::internal::HeapObjectsMap >::Reset(), VirtualMemory::Reset(), FreeListCategory::Reset(), StringCharacterStream::Reset(), SplayTree< v8::internal::DispatchTable::Config, ZoneAllocationPolicy >::ResetRoot(), Scope::ResolveVariable(), ThreadManager::RestoreThread(), Isolate::RestoreThread(), ScavengeWeakObjectRetainer::RetainAs(), MarkCompactWeakObjectRetainer::RetainAs(), Isolate::ReThrow(), HandleScopeImplementer::ReturnBlock(), Rewriter::Rewrite(), CompilationInfo::RollbackDependencies(), HRepresentationChangesPhase::Run(), HMergeRemovableSimulatesPhase::Run(), HRedundantPhiEliminationPhase::Run(), HRangeAnalysisPhase::Run(), SweeperThread::Run(), HEnvironmentLivenessAnalysisPhase::Run(), ReadQueueTask::Run(), HComputeChangeUndefinedToNaN::Run(), OptimizingCompilerThread::Run(), Execution::RunMicrotasks(), RUNTIME_FUNCTION(), SafeStackFrameIterator::SafeStackFrameIterator(), Sampler::SampleStack(), Scope::Scope(), HControlInstruction::SecondSuccessor(), SemiSpaceIterator::SemiSpaceIterator(), HeapSnapshotJSONSerializer::Serialize(), StartupSerializer::SerializeStrongReferences(), SetOncePointer< HConstant >::set(), Isolate::set_context(), CompilationInfo::set_deferred_handles(), ParserBase< Traits >::BASE_EMBEDDED::set_generator_object_variable(), HeapObject::set_map(), JSObject::set_map_and_elements(), FreeListNode::set_next(), V8_FINAL< kOperandKind, kNumCachedOperands >::set_parent_loop_header(), BASE_EMBEDDED< Visitor >::set_redirector(), ExternalAsciiString::set_resource(), ExternalTwoByteString::set_resource(), Assembler::set_target_address_at(), V8::SetArrayBufferAllocator(), HValue::SetBlock(), CompilationInfo::SetCachedData(), Logger::SetCodeEventHandler(), JSObject::SetElement(), CompilationInfo::SetFunction(), CompilationInfo::SetGlobalScope(), RegExpImpl::SetLastMatchInfo(), PagedSpace::SetPagesToSweep(), Ticker::SetProfiler(), JSObject::SetPropertyWithCallback(), JSObject::SetPrototype(), LiveRange::SetSpillOperand(), Heap::SetStackLimits(), CpuProfiler::SetterCallbackEvent(), Heap::SetUp(), CodeRange::SetUp(), NewSpace::SetUp(), LargeObjectSpace::SetUp(), Runtime::SetupArrayBufferAllocatingData(), HOptimizedGraphBuilder::SetUpScope(), LiveRange::ShortenTo(), LiveRange::ShouldBeAllocatedBefore(), JSObject::ShouldConvertToFastElements(), Isolate::ShouldReportException(), V8::ShutdownPlatform(), SlotsBuffer::SizeOfChain(), Heap::SizeOfObjects(), SlotsBuffer::SlotsBuffer(), PagedSpace::SlowAllocateRaw(), BufferedUtf16CharacterStream::SlowPushBack(), BufferedUtf16CharacterStream::SlowSeekForward(), SmartPointerBase< ObjectDeallocator< v8::internal::HeapObjectsMap >, v8::internal::HeapObjectsMap >::SmartPointerBase(), SplayTree< Config, AllocationPolicy >::Splay(), CharacterRange::Split(), LiveRange::SplitAt(), BASE_EMBEDDED< Visitor >::StackFrame(), Scope::StackLocalCount(), Isolate::StackOverflow(), Isolate::StackTraceString(), CodeRange::start(), SamplingCircularQueue< T, Length >::StartEnqueue(), ProfilerExtension::StartProfiling(), Thread::StartSynchronously(), ProfilerEventsProcessor::StartTickSample(), CpuProfiler::StartTickSample(), FullCodeGenerator::State2String(), StateToString(), CompareIC::StateToType(), HeapProfiler::StopHeapObjectsTracking(), Logger::StopProfiler(), CpuProfiler::StopProfiling(), CpuProfilesCollection::StopProfiling(), KeyedStoreIC::Store(), StoreBufferRebuildScope::StoreBufferRebuildScope(), JSObjectWalkVisitor< ContextObject >::StructureWalk(), OptimizedFrame::Summarize(), MarkCompactCollector::SweepConservatively(), V8HeapExplorer::TagGlobalObjects(), HUseListNode::tail(), HeapProfiler::TakeSnapshot(), Assembler::target_address_at(), BASE_EMBEDDED< Visitor >::TargetScope(), StoreBuffer::TearDown(), V8::TearDown(), Bootstrapper::TearDown(), ElementsAccessor::TearDown(), Logger::TearDown(), SamplerThread::TearDown(), Heap::TearDown(), CodeRange::TearDown(), SemiSpace::TearDown(), NewSpace::TearDown(), LargeObjectSpace::TearDown(), ParserTraits::TearDownFunctionState(), ThreadManager::TerminateExecution(), Isolate::TerminateExecution(), TEST(), TEST(), Isolate::ThrowInvalidStringLength(), String::ToCString(), LiveRange::TopLevel(), LCodeGen::ToRegister32(), OS::TotalPhysicalMemory(), Map::TraverseTransitionTree(), LControlInstruction< 0, 1 >::TrueLabel(), HValue::TryDecompose(), IC::TryRemoveInvalidPrototypeDependentStub(), V8_FINAL< kOperandKind, kNumCachedOperands >::uint32_instructions(), InternalFrame::unchecked_code(), StubFailureTrampolineFrame::unchecked_code(), Interface::Unify(), FixedArray::UnionOfKeys(), V8_FINAL< kOperandKind, kNumCachedOperands >::Unique(), MemoryChunk::Unlink(), HInstruction::Unlink(), BreakIterator::UnpackBreakIterator(), Collator::UnpackCollator(), DateFormat::UnpackDateFormat(), NumberFormat::UnpackNumberFormat(), Isolate::UnregisterTryCatchHandler(), SkipList::Update(), KeyedLookupCache::Update(), HeapObjectsMap::UpdateHeapObjectsMap(), MemoryChunk::UpdateHighWaterMark(), BoundsCheckBbData::UpdateLowerOffsets(), Heap::UpdateNewSpaceReferencesInExternalStringTable(), SlotsBuffer::UpdateSlotsRecordedIn(), BoundsCheckBbData::UpdateUpperOffsets(), UsePosition::UsePosition(), Vector< const uint8_t >::Vector(), VirtualMemory::VirtualMemory(), String::Visit(), PointersUpdatingVisitor::VisitCodeAgeSequence(), EnumerateOptimizedFunctionsVisitor::VisitFunction(), HOptimizedGraphBuilder::VisitLogicalExpression(), HOptimizedGraphBuilder::VisitNot(), Code::WipeOutHeader(), WriteChars(), LCodeGen::WriteTranslation(), Access< T >::~Access(), AlternativeGenerationList::~AlternativeGenerationList(), AssemblerBase::~AssemblerBase(), CompilationInfo::~CompilationInfo(), DateCache::~DateCache(), Deoptimizer::~Deoptimizer(), DeoptimizerData::~DeoptimizerData(), Deserializer::~Deserializer(), FileByteSink::~FileByteSink(), GlobalHandles::~GlobalHandles(), LAllocatorPhase::~LAllocatorPhase(), LowLevelLogger::~LowLevelLogger(), NativeObjectsExplorer::~NativeObjectsExplorer(), ObjectGroup::~ObjectGroup(), OptimizingCompilerThread::~OptimizingCompilerThread(), Parser::~Parser(), PerfBasicLogger::~PerfBasicLogger(), PerfJitLogger::~PerfJitLogger(), PerThreadAssertScopeBase::~PerThreadAssertScopeBase(), BASE_EMBEDDED< Visitor >::~SaveContext(), StringsStorage::~StringsStorage(), and Win32MemoryMappedFile::~Win32MemoryMappedFile().

kSerializedDataOffset kPrototypeTemplateOffset kIndexedPropertyHandlerOffset kInstanceCallHandlerOffset Object

Definition at line 5016 of file objects-inl.h.

Referenced by CacheInitialJSArrayMaps(), DictionaryElementsAccessor::DeleteCommon(), GetProperty(), Object::GetProperty(), JSObject::PrepareSlowElementsForSort(), DictionaryElementsAccessor::SetLengthWithoutNormalize(), ExternalInt8Array::SetValue(), ExternalUint8Array::SetValue(), ExternalInt16Array::SetValue(), ExternalUint16Array::SetValue(), ExternalInt32Array::SetValue(), ExternalUint32Array::SetValue(), ExternalFloat32Array::SetValue(), ExternalFloat64Array::SetValue(), FixedTypedArray< Traits >::SetValue(), TEST(), THREADED_TEST(), and Factory::ToObject().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to optimize

Definition at line 317 of file flags.cc.

const Register pc = { kRegister_pc_Code }

Definition at line 244 of file assembler-arm.h.

Referenced by BackEdgeTable::AddStackCheck(), Instruction::At(), Isolate::CaptureCurrentStackTrace(), generate(), OptimizedFrame::GetDeoptimizationData(), Assembler::instr_at(), Assembler::instr_at_put(), StandardFrame::IterateCompiledFrame(), JavaScriptFrame::Print(), BackEdgeTable::RemoveStackCheck(), BASE_EMBEDDED< Visitor >::Reposition(), RUNTIME_FUNCTION(), BASE_EMBEDDED< Visitor >::set_pc(), Assembler::set_target_address_at(), FrameDescription::SetContinuation(), FrameDescription::SetPc(), Code::SourcePosition(), JavaScriptFrame::Summarize(), TEST(), StubFrame::unchecked_code(), and SlotsBuffer::UpdateSlotsWithFilter().

const Register pp = { kRegister_r8_Code }

Definition at line 49 of file macro-assembler-arm.h.

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations Used with prof

Definition at line 803 of file flags.cc.

kSerializedDataOffset prototype_template

Definition at line 5016 of file objects-inl.h.

Referenced by FunctionTemplate::PrototypeTemplate().

const QwNeonRegister q0 = { 0 }

Definition at line 463 of file assembler-arm.h.

Referenced by TEST().

const QwNeonRegister q1 = { 1 }

Definition at line 464 of file assembler-arm.h.

Referenced by MultiplierAndShift::MultiplierAndShift(), and TEST().

const QwNeonRegister q10 = { 10 }

Definition at line 473 of file assembler-arm.h.

const QwNeonRegister q11 = { 11 }

Definition at line 474 of file assembler-arm.h.

const QwNeonRegister q12 = { 12 }

Definition at line 475 of file assembler-arm.h.

const QwNeonRegister q13 = { 13 }

Definition at line 476 of file assembler-arm.h.

const QwNeonRegister q14 = { 14 }

Definition at line 477 of file assembler-arm.h.

const QwNeonRegister q15 = { 15 }

Definition at line 478 of file assembler-arm.h.

const QwNeonRegister q2 = { 2 }

Definition at line 465 of file assembler-arm.h.

Referenced by MultiplierAndShift::MultiplierAndShift(), and TEST().

const QwNeonRegister q3 = { 3 }

Definition at line 466 of file assembler-arm.h.

Referenced by TEST().

const QwNeonRegister q4 = { 4 }

Definition at line 467 of file assembler-arm.h.

Referenced by TEST().

const QwNeonRegister q5 = { 5 }

Definition at line 468 of file assembler-arm.h.

const QwNeonRegister q6 = { 6 }

Definition at line 469 of file assembler-arm.h.

const QwNeonRegister q7 = { 7 }

Definition at line 470 of file assembler-arm.h.

const QwNeonRegister q8 = { 8 }

Definition at line 471 of file assembler-arm.h.

const QwNeonRegister q9 = { 9 }

Definition at line 472 of file assembler-arm.h.

const Register r0 = { kRegister_r0_Code }

Definition at line 225 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredAllocate(), LCodeGen::DoDeferredInstanceMigration(), LCodeGen::DoDeferredInstanceOfKnownGlobal(), LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), LCodeGen::DoDeferredNumberTagD(), LCodeGen::DoDeferredNumberTagIU(), LCodeGen::DoDeferredStringCharCodeAt(), LCodeGen::DoDeferredStringCharFromCode(), generate(), MakeConvertDToIFuncTrampoline(), and TEST().

const Register r1 = { kRegister_r1_Code }

Definition at line 226 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), MakeConvertDToIFuncTrampoline(), MultiplierAndShift::MultiplierAndShift(), TEST(), and THREADED_TEST().

const Register r10 = { kRegister_r10_Code }

Definition at line 239 of file assembler-arm.h.

Referenced by TEST(), and THREADED_TEST().

const Register r11 = { kRegister_r11_Code }

Definition at line 175 of file assembler-x64.h.

Referenced by TEST(), TestI64PlusConstantToSmi(), TestPositiveSmiPowerUp(), TestSmiAnd(), TestSmiDiv(), TestSmiMod(), TestSmiMul(), TestSmiNeg(), TestSmiNot(), TestSmiOr(), TestSmiShiftArithmeticRight(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), and TestSmiXor().

const Register r12 = { kRegister_r12_Code }

Definition at line 176 of file assembler-x64.h.

const Register r13 = { kRegister_r13_Code }

Definition at line 177 of file assembler-x64.h.

Referenced by TEST().

const Register r14 = { kRegister_r14_Code }

Definition at line 178 of file assembler-x64.h.

Referenced by TEST(), TestSmiDiv(), and TestSmiMod().

const Register r15 = { kRegister_r15_Code }

Definition at line 179 of file assembler-x64.h.

Referenced by TEST(), TestSmiDiv(), and TestSmiMod().

const Register r2 = { kRegister_r2_Code }

Definition at line 227 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), MultiplierAndShift::MultiplierAndShift(), TEST(), and THREADED_TEST().

const Register r3 = { kRegister_r3_Code }

Definition at line 228 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), TEST(), and THREADED_TEST().

const Register r4 = { kRegister_r4_Code }

Definition at line 229 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredMathAbsTaggedHeapNumber(), MakeConvertDToIFuncTrampoline(), TEST(), and THREADED_TEST().

const Register r5 = { kRegister_r5_Code }

Definition at line 230 of file assembler-arm.h.

Referenced by LCodeGen::DoDeferredInstanceOfKnownGlobal(), MakeConvertDToIFuncTrampoline(), TEST(), and THREADED_TEST().

const Register r6 = { kRegister_r6_Code }

Definition at line 231 of file assembler-arm.h.

Referenced by MakeConvertDToIFuncTrampoline(), TEST(), and THREADED_TEST().

const Register r7 = { kRegister_r7_Code }

Definition at line 233 of file assembler-arm.h.

Referenced by MakeConvertDToIFuncTrampoline(), TEST(), and THREADED_TEST().

const Register r8 = { kRegister_r8_Code }

Definition at line 235 of file assembler-arm.h.

Referenced by TEST(), TestI64PlusConstantToSmi(), TestPositiveSmiPowerUp(), TestSmiAnd(), TestSmiCompare(), TestSmiDiv(), TestSmiIndex(), TestSmiMod(), TestSmiMul(), TestSmiNeg(), TestSmiNot(), TestSmiOr(), TestSmiShiftArithmeticRight(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), TestSmiXor(), and THREADED_TEST().

const Register r9 = { kRegister_r9_Code }

Definition at line 237 of file assembler-arm.h.

Referenced by TEST(), TestSelectNonSmi(), TestSmiAnd(), TestSmiCompare(), TestSmiDiv(), TestSmiMod(), TestSmiMul(), TestSmiNeg(), TestSmiNot(), TestSmiOr(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), TestSmiXor(), and THREADED_TEST().

const Register rax = { kRegister_rax_Code }

Definition at line 164 of file assembler-x64.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), TEST(), TestI64PlusConstantToSmi(), TestPositiveSmiPowerUp(), TestSelectNonSmi(), TestSmiAnd(), TestSmiCompare(), TestSmiIndex(), TestSmiMul(), TestSmiNeg(), TestSmiNot(), TestSmiOr(), TestSmiShiftArithmeticRight(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), and TestSmiXor().

const Register rbp = { kRegister_rbp_Code }

Definition at line 169 of file assembler-x64.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const Register rbx = { kRegister_rbx_Code }

Definition at line 167 of file assembler-x64.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), and TEST().

const Register rcx = { kRegister_rcx_Code }

Definition at line 165 of file assembler-x64.h.

Referenced by generate(), MakeConvertDToIFuncTrampoline(), TEST(), TestI64PlusConstantToSmi(), TestPositiveSmiPowerUp(), TestSelectNonSmi(), TestSmiAnd(), TestSmiCompare(), TestSmiDiv(), TestSmiIndex(), TestSmiMod(), TestSmiMul(), TestSmiNeg(), TestSmiNot(), TestSmiOr(), TestSmiShiftArithmeticRight(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), and TestSmiXor().

const Register rdi = { kRegister_rdi_Code }

Definition at line 171 of file assembler-x64.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const Register rdx = { kRegister_rdx_Code }

Definition at line 166 of file assembler-x64.h.

Referenced by MakeConvertDToIFuncTrampoline(), TEST(), TestI64PlusConstantToSmi(), TestPositiveSmiPowerUp(), TestSelectNonSmi(), TestSmiAnd(), TestSmiCompare(), TestSmiIndex(), TestSmiMul(), TestSmiOr(), TestSmiShiftArithmeticRight(), TestSmiShiftLeft(), TestSmiShiftLogicalRight(), and TestSmiXor().

kInstanceClassNameOffset kNeedsAccessCheckBit remove_prototype

Definition at line 5119 of file objects-inl.h.

const Register rsi = { kRegister_rsi_Code }

Definition at line 170 of file assembler-x64.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const Register rsp = { kRegister_rsp_Code }

Definition at line 168 of file assembler-x64.h.

Referenced by MakeConvertDToIFuncTrampoline(), StackOperandForReturnAddress(), StackSpaceOperand(), and TEST().

const Instr rtCallRedirInstr = SPECIAL | BREAK | call_rt_redirected << 6

Definition at line 611 of file constants-mips.h.

const SwVfpRegister s0 = { 0 }

Definition at line 396 of file assembler-arm.h.

Referenced by MacroAssembler::PrepareCEntryArgs(), TEST(), TEST_(), and THREADED_TEST().

const SwVfpRegister s1 = { 1 }

Definition at line 397 of file assembler-arm.h.

Referenced by NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16(), V8_FINAL< kOperandKind, kNumCachedOperands >::Match(), MacroAssembler::PrepareCEntryArgs(), TEST(), TEST_(), and TestViewFromApi().

const SwVfpRegister s10 = { 10 }

Definition at line 406 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s11 = { 11 }

Definition at line 407 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s12 = { 12 }

Definition at line 408 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s13 = { 13 }

Definition at line 409 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s14 = { 14 }

Definition at line 410 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s15 = { 15 }

Definition at line 411 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s16 = { 16 }

Definition at line 412 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s17 = { 17 }

Definition at line 413 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s18 = { 18 }

Definition at line 414 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s19 = { 19 }

Definition at line 415 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s2 = { 2 }

Definition at line 398 of file assembler-arm.h.

Referenced by NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16(), V8_FINAL< kOperandKind, kNumCachedOperands >::Match(), MacroAssembler::PrepareCEntryFunction(), TEST(), TEST_(), and TestViewFromApi().

const SwVfpRegister s20 = { 20 }

Definition at line 416 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s21 = { 21 }

Definition at line 417 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s22 = { 22 }

Definition at line 418 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s23 = { 23 }

Definition at line 419 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s24 = { 24 }

Definition at line 420 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s25 = { 25 }

Definition at line 421 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s26 = { 26 }

Definition at line 422 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s27 = { 27 }

Definition at line 423 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s28 = { 28 }

Definition at line 424 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s29 = { 29 }

Definition at line 425 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s3 = { 3 }

Definition at line 399 of file assembler-arm.h.

Referenced by TEST(), TEST_(), TestViewFromApi(), and THREADED_TEST().

const SwVfpRegister s30 = { 30 }

Definition at line 426 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s31 = { 31 }

Definition at line 427 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s4 = { 4 }

Definition at line 400 of file assembler-arm.h.

Referenced by TEST(), TEST_(), and THREADED_TEST().

const SwVfpRegister s5 = { 5 }

Definition at line 401 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s6 = { 6 }

Definition at line 402 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s7 = { 7 }

Definition at line 403 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s8 = { 8 }

Definition at line 404 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

const SwVfpRegister s9 = { 9 }

Definition at line 405 of file assembler-arm.h.

Referenced by TEST(), and TEST_().

TickSample* sample

Definition at line 79 of file trace-extension.cc.

Referenced by Counter::AddSample(), Profiler::Disengage(), TraceExtension::InitTraceEnv(), Profiler::Insert(), Profiler::Run(), Sampler::SampleStack(), and TEST().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp serdes

Definition at line 642 of file flags.cc.

serialized_data

Definition at line 4980 of file objects-inl.h.

Referenced by TEST().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array shift

Definition at line 211 of file flags.cc.

Referenced by BitFieldBase< LoadKeyedHoleMode, shift, size, uint32_t >::decode(), BitFieldBase< LoadKeyedHoleMode, shift, size, uint32_t >::encode(), Internals::GetNodeFlag(), V8_FINAL< kOperandKind, kNumCachedOperands >::IndexFor(), IntegerLog2(), ParserTraits::ShortcutNumericLiteralBinaryExpression(), TEST(), and Internals::UpdateNodeFlag().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object size

Definition at line 211 of file flags.cc.

Referenced by AllocationTraceNode::AddAllocation(), AddressToTraceMap::AddRange(), zone_allocator< T >::allocate(), Serializer::Allocate(), DescriptorArray::Allocate(), BasicHeapEntriesAllocator::AllocateEntry(), Heap::AllocateInternalizedStringImpl(), Heap::AllocateOneByteInternalizedString(), CodeRange::AllocateRawMemory(), Heap::AllocateTwoByteInternalizedString(), RegExpStack::ArchiveStack(), CodeStubGraphBuilder< Stub >::BuildCodeStub(), MacroAssembler::Claim(), MacroAssembler::ClaimBySMI(), PagedSpace::CommittedPhysicalMemory(), SemiSpace::CommittedPhysicalMemory(), NewSpace::CommittedPhysicalMemory(), LargeObjectSpace::CommittedPhysicalMemory(), DescriptorArray::CopyUpToAddAttributes(), CPURegister::Create(), Zone::DeleteAll(), Zone::DeleteKeptSegment(), MacroAssembler::Drop(), MacroAssembler::DropBySMI(), DumpBacktrace(), RegExpStack::EnsureCapacity(), PagedSpace::Expand(), HeapObjectsMap::FindOrAddEntry(), MemoryAllocator::FreeMemory(), HeapProfiler::GetMemorySizeUsedByProfiler(), StringsStorage::GetUsedMemorySize(), NativeRegExpMacroAssembler::GrowStack(), V8_FINAL< kOperandKind, kNumCachedOperands >::HasOutOfBoundsAccess(), Assembler::ImmLSPair(), Heap::IncreaseTotalRegexpCodeGenerated(), BASE_EMBEDDED< Visitor >::increment_bytes(), Heap::IncrementCodeGeneratedBytes(), JSObject::InitializeBody(), InitializeICU(), TypeImpl< class >::Intersect(), V8_FINAL< kOperandKind, kNumCachedOperands >::LAllocate(), String::MakeExternal(), Zone::New(), NewArray(), SemiSpaceIterator::Next(), NoAllocationStringAllocator::NoAllocationStringAllocator(), Malloced::operator new(), AstTyper::operator new(), ProfilerEventsProcessor::operator new(), FrameDescription::operator new(), HOptimizedGraphBuilder::operator new(), PerfBasicLogger::PerfBasicLogger(), PerfJitLogger::PerfJitLogger(), ReadFile(), Heap::RecordCodeSubTypeStats(), Heap::RecordFixedArraySubTypeStats(), Heap::RecordObjectStats(), VisitorDispatchTable< ScavengingCallback >::RegisterSpecialization(), PagedSpace::ReleasePage(), PromotionQueue::remove(), CompilationCacheTable::Remove(), RegExpStack::RestoreStack(), RUNTIME_FUNCTION(), Serializer::ObjectSerializer::Serialize(), JSObject::SetPrototype(), CodeRange::SetUp(), NewSpace::SetUp(), FreeSpace::Size(), HeapObject::SizeFromMap(), PagedSpace::SizeOfFirstPage(), MarkCompactCollector::SweepConservatively(), TEST(), TestSet(), OS::TotalPhysicalMemory(), TypeImpl< class >::Union(), MemoryAllocator::ZapBlock(), and LAllocatorPhase::~LAllocatorPhase().

const Register sp = { kRegister_sp_Code }

Definition at line 242 of file assembler-arm.h.

Referenced by CFunctionArgumentOperand(), StandardFrame::ComputeExpressionsCount(), JavaScriptFrame::ComputeOperandsCount(), ExitFrame::FillState(), StubFailureTrampolineFrame::Iterate(), StandardFrame::IterateCompiledFrame(), StandardFrame::IterateExpressions(), MakeConvertDToIFuncTrampoline(), MacroAssembler::Pop(), MacroAssembler::pop(), Assembler::pop(), MacroAssembler::Push(), MacroAssembler::push(), Assembler::push(), SafeStackFrameIterator::SafeStackFrameIterator(), TEST(), LCodeGen::ToHighMemOperand(), and LCodeGen::ToMemOperand().

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation kUsesArguments kFormalParameterCountOffset start_position_and_type

Definition at line 5123 of file objects-inl.h.

struct v8::internal::StaticInitializer static_initializer

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag string flag tmp file in which to serialize heap Print the time it takes to lazily compile hydrogen code stubs concurrent_recompilation concurrent_sweeping Print usage including on console Map counters to a file Enable debugger compile events enable GDBJIT enable GDBJIT interface for all code objects dump only objects containing this substring stress the GC compactor to flush out pretty print source code print source AST function name where to insert a breakpoint print scopes for builtins trace contexts operations print stuff during garbage collection report code statistics after GC report handles after GC trace cache state transitions print interface inference details prints when objects are turned into dictionaries report heap spill statistics along with trace isolate state changes trace regexp bytecode execution Minimal Log all events to the log file Log API events to the log file Log heap samples on garbage collection for the hp2ps tool log positions Log suspect operations true

Definition at line 208 of file flags.cc.

kInstanceClassNameOffset kNeedsAccessCheckBit kRemovePrototypeBit kIsExpressionBit kAllowLazyCompilation uses_arguments

Definition at line 5137 of file objects-inl.h.

const VmovIndex VmovIndexHi = { 1 }

Definition at line 769 of file assembler-arm.h.

Referenced by TEST().

const VmovIndex VmovIndexLo = { 0 }

Definition at line 768 of file assembler-arm.h.

Referenced by TEST().

enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long expose natives in global object expose freeBuffer extension expose gc extension under the specified name expose externalize string extension number of stack frames to capture disable builtin natives files print name of functions for which code is generated use random jit cookie to mask large constants trace lazy optimization use adaptive optimizations always try to OSR functions trace optimize function deoptimization minimum length for automatic enable preparsing maximum number of optimization attempts before giving up cache prototype transitions trace debugging JSON request response trace out of bounds accesses to external arrays trace_js_array_abuse automatically set the debug break flag when debugger commands are in the queue abort by crashing maximum length of function source code printed in a stack trace max size of the new max size of the old max size of executable always perform global GCs print one trace line following each garbage collection do not print trace line after scavenger collection print statistics of the maximum memory committed for the heap in only print modified registers Don t break for ASM_UNIMPLEMENTED_BREAK macros print stack trace when an illegal exception is thrown randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot testing_bool_flag testing_int_flag world

Definition at line 636 of file flags.cc.

const XMMRegister xmm0 = { 0 }

Definition at line 263 of file assembler-x64.h.

Referenced by MakeConvertDToIFuncTrampoline(), and TEST().

const XMMRegister xmm1 = { 1 }

Definition at line 264 of file assembler-x64.h.

Referenced by TEST().

const XMMRegister xmm10 = { 10 }

Definition at line 273 of file assembler-x64.h.

const XMMRegister xmm11 = { 11 }

Definition at line 274 of file assembler-x64.h.

const XMMRegister xmm12 = { 12 }

Definition at line 275 of file assembler-x64.h.

const XMMRegister xmm13 = { 13 }

Definition at line 276 of file assembler-x64.h.

const XMMRegister xmm14 = { 14 }

Definition at line 277 of file assembler-x64.h.

const XMMRegister xmm15 = { 15 }

Definition at line 278 of file assembler-x64.h.

const XMMRegister xmm2 = { 2 }

Definition at line 265 of file assembler-x64.h.

Referenced by TEST().

const XMMRegister xmm3 = { 3 }

Definition at line 266 of file assembler-x64.h.

const XMMRegister xmm4 = { 4 }

Definition at line 267 of file assembler-x64.h.

const XMMRegister xmm5 = { 5 }

Definition at line 268 of file assembler-x64.h.

const XMMRegister xmm6 = { 6 }

Definition at line 269 of file assembler-x64.h.

const XMMRegister xmm7 = { 7 }

Definition at line 270 of file assembler-x64.h.

const XMMRegister xmm8 = { 8 }

Definition at line 271 of file assembler-x64.h.

const XMMRegister xmm9 = { 9 }

Definition at line 272 of file assembler-x64.h.